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.
1362 lines
61 KiB
1362 lines
61 KiB
/******************************Module*Header**********************************\
|
|
*
|
|
* *******************
|
|
* * D3D SAMPLE CODE *
|
|
* *******************
|
|
*
|
|
* Module Name: d3d.c
|
|
*
|
|
* Content: Main D3D capabilites and callback tables
|
|
*
|
|
* Copyright (c) 1994-1999 3Dlabs Inc. Ltd. All rights reserved.
|
|
* Copyright (c) 1995-2003 Microsoft Corporation. All rights reserved.
|
|
\*****************************************************************************/
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//
|
|
// Certain conventions are followed in this sample driver in order to ease
|
|
// the code reading process:
|
|
//
|
|
// - All driver function callbacks are prefixed with either D3D or DD. No other
|
|
// functions start with such a prefix
|
|
//
|
|
// - Helper (or secondary) functions which are called from other places INSIDE
|
|
// the driver (in different files) are prefixed with either _D3D or _DD
|
|
//
|
|
// - Helper functions called from within the same file are prefixed with __
|
|
// (but not with __D3D or __DD !) so names as __CTX_CleanDirect3DContext arise
|
|
//
|
|
// - Data structures declared and used only be the driver are prefixed with P3
|
|
//
|
|
// - Very minor hungarian notation is used, basically in the form of prefixes
|
|
// for DWORDs (dw), pointers (p), handles (h), and counters (i).
|
|
//
|
|
// - Global data items are prefixed with g_
|
|
//
|
|
// - This driver is intended to be source code compatible between the NT and
|
|
// Win9x kernel display driver models. As such, most kernel structures retain
|
|
// their Win9x name ( The DX8 d3dnthal.h shares the same names as the Win9x
|
|
// d3dhal.h and for DX7 dx95type.h in the Win2K DDK will perform the
|
|
// required level of translation). Major differences however are observed
|
|
// using preprocessor #if statements.
|
|
//
|
|
//-----------------------------------------------------------------------------
|
|
|
|
#include "glint.h"
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// in-the-file nonexported forward declarations
|
|
//-----------------------------------------------------------------------------
|
|
void __D3D_BuildTextureFormatsP3(P3_THUNKEDDATA *pThisDisplay,
|
|
DDSURFACEDESC TexFmt[MAX_TEXTURE_FORMAT],
|
|
DWORD *pNumTextures);
|
|
#if DX8_DDI
|
|
void __D3D_Fill_DX8Caps(D3DCAPS8 *pd3d8caps,
|
|
D3DDEVICEDESC_V1 *pDeviceDesc,
|
|
D3DHAL_D3DEXTENDEDCAPS *pD3DEC,
|
|
DDHALINFO *pDDHALInfo);
|
|
#endif // DX8_DDI
|
|
//-----------------------------------------------------------------------------
|
|
// This structure contains all the the primitive capabilities (D3DPRIMCAPS)
|
|
// this driver supports for triangles and lines. All of the information in this
|
|
// table will be implementation specific according to the specifications of
|
|
// the hardware.
|
|
//-----------------------------------------------------------------------------
|
|
|
|
#define P3RXTriCaps { \
|
|
sizeof(D3DPRIMCAPS), \
|
|
D3DPMISCCAPS_CULLCCW | /* MiscCaps */ \
|
|
D3DPMISCCAPS_CULLCW | \
|
|
D3DPMISCCAPS_CULLNONE | \
|
|
D3DPMISCCAPS_MASKZ | \
|
|
D3DPMISCCAPS_LINEPATTERNREP, \
|
|
D3DPRASTERCAPS_DITHER | /* RasterCaps */ \
|
|
D3DPRASTERCAPS_PAT | \
|
|
D3DPRASTERCAPS_SUBPIXEL | \
|
|
D3DPRASTERCAPS_ZTEST | \
|
|
D3DPRASTERCAPS_FOGVERTEX | \
|
|
D3DPRASTERCAPS_FOGTABLE | \
|
|
D3DPRASTERCAPS_ZFOG | \
|
|
D3DPRASTERCAPS_STIPPLE | \
|
|
D3DPRASTERCAPS_MIPMAPLODBIAS, \
|
|
D3DPCMPCAPS_NEVER | /* ZCmpCaps */ \
|
|
D3DPCMPCAPS_LESS | \
|
|
D3DPCMPCAPS_EQUAL | \
|
|
D3DPCMPCAPS_LESSEQUAL | \
|
|
D3DPCMPCAPS_GREATER | \
|
|
D3DPCMPCAPS_NOTEQUAL | \
|
|
D3DPCMPCAPS_GREATEREQUAL | \
|
|
D3DPCMPCAPS_ALWAYS | \
|
|
D3DPCMPCAPS_LESSEQUAL, \
|
|
D3DPBLENDCAPS_ZERO | /* SourceBlendCaps */ \
|
|
D3DPBLENDCAPS_ONE | \
|
|
D3DPBLENDCAPS_SRCALPHA | \
|
|
D3DPBLENDCAPS_INVSRCALPHA | \
|
|
D3DPBLENDCAPS_DESTALPHA | \
|
|
D3DPBLENDCAPS_INVDESTALPHA | \
|
|
D3DPBLENDCAPS_DESTCOLOR | \
|
|
D3DPBLENDCAPS_INVDESTCOLOR | \
|
|
D3DPBLENDCAPS_SRCALPHASAT | \
|
|
D3DPBLENDCAPS_BOTHSRCALPHA | \
|
|
D3DPBLENDCAPS_BOTHINVSRCALPHA, \
|
|
D3DPBLENDCAPS_ZERO | /* DestBlendCaps */ \
|
|
D3DPBLENDCAPS_ONE | \
|
|
D3DPBLENDCAPS_SRCCOLOR | \
|
|
D3DPBLENDCAPS_INVSRCCOLOR | \
|
|
D3DPBLENDCAPS_SRCALPHA | \
|
|
D3DPBLENDCAPS_INVSRCALPHA | \
|
|
D3DPBLENDCAPS_DESTALPHA | \
|
|
D3DPBLENDCAPS_INVDESTALPHA, \
|
|
D3DPCMPCAPS_NEVER | /* Alphatest caps */ \
|
|
D3DPCMPCAPS_LESS | \
|
|
D3DPCMPCAPS_EQUAL | \
|
|
D3DPCMPCAPS_LESSEQUAL | \
|
|
D3DPCMPCAPS_GREATER | \
|
|
D3DPCMPCAPS_NOTEQUAL | \
|
|
D3DPCMPCAPS_GREATEREQUAL | \
|
|
D3DPCMPCAPS_ALWAYS, \
|
|
D3DPSHADECAPS_COLORFLATRGB | /* ShadeCaps */ \
|
|
D3DPSHADECAPS_COLORGOURAUDRGB | \
|
|
D3DPSHADECAPS_SPECULARFLATRGB | \
|
|
D3DPSHADECAPS_SPECULARGOURAUDRGB | \
|
|
D3DPSHADECAPS_FOGFLAT | \
|
|
D3DPSHADECAPS_FOGGOURAUD | \
|
|
D3DPSHADECAPS_ALPHAFLATBLEND | \
|
|
D3DPSHADECAPS_ALPHAGOURAUDBLEND | \
|
|
D3DPSHADECAPS_ALPHAFLATSTIPPLED, \
|
|
D3DPTEXTURECAPS_PERSPECTIVE | /* TextureCaps */ \
|
|
D3DPTEXTURECAPS_ALPHA | \
|
|
D3DPTEXTURECAPS_POW2 | \
|
|
D3DPTEXTURECAPS_ALPHAPALETTE | \
|
|
D3DPTEXTURECAPS_TRANSPARENCY, \
|
|
D3DPTFILTERCAPS_NEAREST | /* TextureFilterCaps*/ \
|
|
D3DPTFILTERCAPS_LINEAR | \
|
|
D3DPTFILTERCAPS_MIPNEAREST | \
|
|
D3DPTFILTERCAPS_MIPLINEAR | \
|
|
D3DPTFILTERCAPS_LINEARMIPNEAREST | \
|
|
D3DPTFILTERCAPS_LINEARMIPLINEAR | \
|
|
D3DPTFILTERCAPS_MIPFPOINT | \
|
|
D3DPTFILTERCAPS_MIPFLINEAR | \
|
|
D3DPTFILTERCAPS_MAGFPOINT | \
|
|
D3DPTFILTERCAPS_MAGFLINEAR | \
|
|
D3DPTFILTERCAPS_MINFPOINT | \
|
|
D3DPTFILTERCAPS_MINFLINEAR, \
|
|
D3DPTBLENDCAPS_DECAL | /* TextureBlendCaps */ \
|
|
D3DPTBLENDCAPS_DECALALPHA | \
|
|
D3DPTBLENDCAPS_MODULATE | \
|
|
D3DPTBLENDCAPS_MODULATEALPHA | \
|
|
D3DPTBLENDCAPS_ADD | \
|
|
D3DPTBLENDCAPS_COPY, \
|
|
D3DPTADDRESSCAPS_WRAP | /* TextureAddressCaps */ \
|
|
D3DPTADDRESSCAPS_MIRROR | \
|
|
D3DPTADDRESSCAPS_CLAMP | \
|
|
D3DPTADDRESSCAPS_INDEPENDENTUV, \
|
|
8, /* StippleWidth */ \
|
|
8 /* StippleHeight */ \
|
|
}
|
|
|
|
static D3DDEVICEDESC_V1 g_P3RXCaps = {
|
|
sizeof(D3DDEVICEDESC_V1), // dwSize
|
|
D3DDD_COLORMODEL | // dwFlags
|
|
D3DDD_DEVCAPS |
|
|
D3DDD_TRICAPS |
|
|
D3DDD_LINECAPS |
|
|
D3DDD_DEVICERENDERBITDEPTH |
|
|
D3DDD_DEVICEZBUFFERBITDEPTH,
|
|
D3DCOLOR_RGB , // dcmColorModel
|
|
D3DDEVCAPS_CANRENDERAFTERFLIP | // devCaps
|
|
D3DDEVCAPS_FLOATTLVERTEX |
|
|
D3DDEVCAPS_SORTINCREASINGZ |
|
|
D3DDEVCAPS_SORTEXACT |
|
|
D3DDEVCAPS_TLVERTEXSYSTEMMEMORY |
|
|
D3DDEVCAPS_EXECUTESYSTEMMEMORY |
|
|
D3DDEVCAPS_TEXTUREVIDEOMEMORY |
|
|
D3DDEVCAPS_DRAWPRIMTLVERTEX |
|
|
D3DDEVCAPS_DRAWPRIMITIVES2 |
|
|
#if DX7_VERTEXBUFFERS
|
|
D3DDEVCAPS_HWVERTEXBUFFER |
|
|
#endif
|
|
D3DDEVCAPS_HWRASTERIZATION |
|
|
D3DDEVCAPS_DRAWPRIMITIVES2EX,
|
|
{ sizeof(D3DTRANSFORMCAPS), 0 }, // transformCaps
|
|
FALSE, // bClipping
|
|
{ sizeof(D3DLIGHTINGCAPS), 0 }, // lightingCaps
|
|
P3RXTriCaps, // lineCaps
|
|
P3RXTriCaps, // triCaps
|
|
DDBD_16 | DDBD_32, // dwDeviceRenderBitDepth
|
|
DDBD_16 | DDBD_32, // Z Bit depths
|
|
0, // dwMaxBufferSize
|
|
0 // dwMaxVertexCount
|
|
};
|
|
|
|
D3DHAL_D3DEXTENDEDCAPS gc_D3DEC = {
|
|
sizeof(D3DHAL_D3DEXTENDEDCAPS), // dwSize // DX5
|
|
1, // dwMinTextureWidth
|
|
2048, // dwMaxTextureWidth
|
|
1, // dwMinTextureHeight
|
|
2048, // dwMaxTextureHeight
|
|
32, // dwMinStippleWidth
|
|
32, // dwMaxStippleWidth
|
|
32, // dwMinStippleHeight
|
|
32, // dwMaxStippleHeight
|
|
|
|
0, /*azn*/ // dwMaxTextureRepeat //DX6
|
|
0, // dwMaxTextureAspectRatio (no limit)
|
|
0, // dwMaxAnisotropy
|
|
-4096.0f, // dvGuardBandLeft
|
|
-4096.0f, // dvGuardBandTop
|
|
4096.0f, // dvGuardBandRight
|
|
4096.0f, // dvGuardBandBottom
|
|
0.0f, // dvExtentsAdjust
|
|
D3DSTENCILCAPS_KEEP | // dwStencilCaps
|
|
D3DSTENCILCAPS_ZERO |
|
|
D3DSTENCILCAPS_REPLACE |
|
|
D3DSTENCILCAPS_INCRSAT |
|
|
D3DSTENCILCAPS_DECRSAT |
|
|
D3DSTENCILCAPS_INVERT |
|
|
D3DSTENCILCAPS_INCR |
|
|
D3DSTENCILCAPS_DECR,
|
|
8, // dwFVFCaps
|
|
D3DTEXOPCAPS_DISABLE | // dwTextureOpCaps
|
|
D3DTEXOPCAPS_SELECTARG1 |
|
|
D3DTEXOPCAPS_SELECTARG2 |
|
|
D3DTEXOPCAPS_MODULATE |
|
|
D3DTEXOPCAPS_MODULATE2X |
|
|
D3DTEXOPCAPS_MODULATE4X |
|
|
D3DTEXOPCAPS_ADD |
|
|
D3DTEXOPCAPS_ADDSIGNED |
|
|
D3DTEXOPCAPS_ADDSIGNED2X |
|
|
D3DTEXOPCAPS_SUBTRACT |
|
|
D3DTEXOPCAPS_ADDSMOOTH |
|
|
D3DTEXOPCAPS_BLENDDIFFUSEALPHA |
|
|
D3DTEXOPCAPS_BLENDTEXTUREALPHA |
|
|
D3DTEXOPCAPS_BLENDFACTORALPHA |
|
|
//@@BEGIN_DDKSPLIT
|
|
#if 0
|
|
// Fix texturestage DCT - seems we can't do this reliably
|
|
D3DTEXOPCAPS_BLENDTEXTUREALPHAPM |
|
|
D3DTEXOPCAPS_PREMODULATE |
|
|
D3DTEXOPCAPS_BLENDCURRENTALPHA |
|
|
#endif
|
|
//@@END_DDKSPLIT
|
|
D3DTEXOPCAPS_MODULATEALPHA_ADDCOLOR |
|
|
D3DTEXOPCAPS_MODULATECOLOR_ADDALPHA |
|
|
D3DTEXOPCAPS_MODULATEINVALPHA_ADDCOLOR |
|
|
D3DTEXOPCAPS_MODULATEINVCOLOR_ADDALPHA |
|
|
D3DTEXOPCAPS_DOTPRODUCT3,
|
|
2, // wMaxTextureBlendStages
|
|
2, // wMaxSimultaneousTextures
|
|
|
|
0, // dwMaxActiveLights // DX7
|
|
0.0f, // dvMaxVertexW
|
|
0, // wMaxUserClipPlanes
|
|
0 // wMaxVertexBlendMatrices
|
|
};
|
|
|
|
#if DX8_DDI
|
|
static D3DCAPS8 g_P3RX_D3DCaps8;
|
|
#endif // DX8_DDI
|
|
|
|
//--------------------------------------------------------
|
|
// Supported ZBuffer/Stencil Formats by this hardware
|
|
//--------------------------------------------------------
|
|
|
|
#define P3RX_Z_FORMATS 4
|
|
|
|
typedef struct
|
|
{
|
|
DWORD dwStructSize;
|
|
|
|
DDPIXELFORMAT Format[P3RX_Z_FORMATS];
|
|
} ZFormats;
|
|
|
|
ZFormats P3RXZFormats =
|
|
{
|
|
P3RX_Z_FORMATS,
|
|
{
|
|
// Format 1 - 16 Bit Z Buffer, no stencil
|
|
{
|
|
sizeof(DDPIXELFORMAT),
|
|
DDPF_ZBUFFER,
|
|
0,
|
|
16, // Total bits in buffer
|
|
0, // Stencil bits
|
|
0xFFFF, // Z mask
|
|
0, // Stencil mask
|
|
0
|
|
},
|
|
// Format 2 - 24 bit Z Buffer, 8 bit stencil
|
|
{
|
|
sizeof(DDPIXELFORMAT),
|
|
DDPF_ZBUFFER | DDPF_STENCILBUFFER,
|
|
0,
|
|
32, // Total bits in buffer
|
|
8, // Stencil bits
|
|
0x00FFFFFF, // Z Mask
|
|
0xFF000000, // Stencil Mask
|
|
0
|
|
},
|
|
// Format 3 - 15 bit Z Buffer, 1 bit stencil
|
|
{
|
|
sizeof(DDPIXELFORMAT),
|
|
DDPF_ZBUFFER | DDPF_STENCILBUFFER,
|
|
0,
|
|
16, // Total bits in buffer
|
|
1, // Stencil bits
|
|
0x7FFF, // Z Mask
|
|
0x8000, // Stencil mask
|
|
0
|
|
},
|
|
// Format 4 - 32 bit Z Buffer, no stencil
|
|
{
|
|
sizeof(DDPIXELFORMAT),
|
|
DDPF_ZBUFFER,
|
|
0,
|
|
32, // Total bits in buffer
|
|
0, // Stencil bits
|
|
0xFFFFFFFF, // Z Mask
|
|
0, // Stencil Mask
|
|
0
|
|
}
|
|
}
|
|
};
|
|
|
|
#if DX8_DDI
|
|
//----------------------------------------------------------------------------
|
|
// Supported DX8 RenderTarget/Texture/ZBuffer/Stencil Formats by this hardware
|
|
//----------------------------------------------------------------------------
|
|
|
|
#if DX8_MULTISAMPLING
|
|
// Note: For multisampling we need to setup appropriately both the rendertarget
|
|
// and the depth buffer format's multisampling fields.
|
|
#define D3DMULTISAMPLE_NUM_SAMPLES (1 << (D3DMULTISAMPLE_4_SAMPLES - 1))
|
|
#else
|
|
#define D3DMULTISAMPLE_NUM_SAMPLES D3DMULTISAMPLE_NONE
|
|
#endif // DX8_MULTISAMPLING
|
|
|
|
#define DX8_FORMAT(FourCC, Ops, dwMSFlipTypes) \
|
|
{ sizeof(DDPIXELFORMAT), DDPF_D3DFORMAT, (FourCC), 0, (Ops), \
|
|
((dwMSFlipTypes) & 0xFFFF ) << 16 | ((dwMSFlipTypes) & 0xFFFF), 0, 0 }
|
|
|
|
DDPIXELFORMAT DX8FormatTable[] =
|
|
{
|
|
DX8_FORMAT(D3DFMT_X1R5G5B5, D3DFORMAT_OP_TEXTURE |
|
|
D3DFORMAT_OP_VOLUMETEXTURE |
|
|
D3DFORMAT_OP_SAME_FORMAT_RENDERTARGET,
|
|
D3DMULTISAMPLE_NUM_SAMPLES ),
|
|
DX8_FORMAT(D3DFMT_R5G6B5, D3DFORMAT_OP_TEXTURE |
|
|
D3DFORMAT_OP_VOLUMETEXTURE |
|
|
D3DFORMAT_OP_DISPLAYMODE |
|
|
D3DFORMAT_OP_3DACCELERATION |
|
|
D3DFORMAT_OP_SAME_FORMAT_RENDERTARGET,
|
|
D3DMULTISAMPLE_NUM_SAMPLES ),
|
|
DX8_FORMAT(D3DFMT_X8R8G8B8, D3DFORMAT_OP_TEXTURE |
|
|
D3DFORMAT_OP_VOLUMETEXTURE |
|
|
D3DFORMAT_OP_DISPLAYMODE |
|
|
D3DFORMAT_OP_3DACCELERATION |
|
|
D3DFORMAT_OP_SAME_FORMAT_RENDERTARGET, 0),
|
|
#ifdef DX7_PALETTETEXTURE
|
|
DX8_FORMAT(D3DFMT_P8, D3DFORMAT_OP_TEXTURE |
|
|
D3DFORMAT_OP_VOLUMETEXTURE, 0),
|
|
#endif
|
|
|
|
DX8_FORMAT(D3DFMT_A1R5G5B5, D3DFORMAT_OP_TEXTURE |
|
|
D3DFORMAT_OP_VOLUMETEXTURE, 0),
|
|
DX8_FORMAT(D3DFMT_A4R4G4B4, D3DFORMAT_OP_TEXTURE |
|
|
D3DFORMAT_OP_VOLUMETEXTURE, 0),
|
|
DX8_FORMAT(D3DFMT_A8R8G8B8, D3DFORMAT_OP_TEXTURE |
|
|
D3DFORMAT_OP_VOLUMETEXTURE, 0),
|
|
DX8_FORMAT(D3DFMT_A4L4, D3DFORMAT_OP_TEXTURE |
|
|
D3DFORMAT_OP_VOLUMETEXTURE, 0),
|
|
DX8_FORMAT(D3DFMT_A8L8, D3DFORMAT_OP_TEXTURE |
|
|
D3DFORMAT_OP_VOLUMETEXTURE, 0),
|
|
//@@BEGIN_DDKSPLIT
|
|
// We are turning D3DFMT_A8 support OFF because the default color for
|
|
// this format has been changed from white to black. The P3 has white
|
|
// hardwired so there is no simple solution for this.
|
|
#if 0
|
|
DX8_FORMAT(D3DFMT_A8, D3DFORMAT_OP_TEXTURE |
|
|
D3DFORMAT_OP_VOLUMETEXTURE, 0),
|
|
#endif
|
|
//@@END_DDKSPLIT
|
|
DX8_FORMAT(D3DFMT_L8, D3DFORMAT_OP_TEXTURE |
|
|
D3DFORMAT_OP_VOLUMETEXTURE, 0),
|
|
DX8_FORMAT(D3DFMT_D16_LOCKABLE, D3DFORMAT_OP_ZSTENCIL |
|
|
D3DFORMAT_OP_ZSTENCIL_WITH_ARBITRARY_COLOR_DEPTH ,
|
|
D3DMULTISAMPLE_NUM_SAMPLES ),
|
|
DX8_FORMAT(D3DFMT_D32, D3DFORMAT_OP_ZSTENCIL |
|
|
D3DFORMAT_OP_ZSTENCIL_WITH_ARBITRARY_COLOR_DEPTH ,
|
|
D3DMULTISAMPLE_NUM_SAMPLES ),
|
|
DX8_FORMAT(D3DFMT_S8D24, D3DFORMAT_OP_ZSTENCIL |
|
|
D3DFORMAT_OP_ZSTENCIL_WITH_ARBITRARY_COLOR_DEPTH ,
|
|
D3DMULTISAMPLE_NUM_SAMPLES ),
|
|
DX8_FORMAT(D3DFMT_S1D15, D3DFORMAT_OP_ZSTENCIL |
|
|
D3DFORMAT_OP_ZSTENCIL_WITH_ARBITRARY_COLOR_DEPTH ,
|
|
D3DMULTISAMPLE_NUM_SAMPLES )
|
|
};
|
|
#define DX8_FORMAT_COUNT (sizeof(DX8FormatTable) / sizeof(DX8FormatTable[0]))
|
|
#endif // DX8_DDI
|
|
|
|
#ifdef W95_DDRAW
|
|
#define DDHAL_D3DBUFCALLBACKS DDHAL_DDEXEBUFCALLBACKS
|
|
#endif
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//
|
|
// void _D3DHALCreateDriver
|
|
//
|
|
// _D3DHALCreateDriver is a helper function, not a callback.
|
|
//
|
|
// Its main purpouse is to centralize the first part of D3D initialization
|
|
// (the second part is handled by _D3DGetDriverInfo) . _D3DHALCreateDriver:
|
|
// Clears contexts
|
|
// Fills entry points to D3D driver.
|
|
// Generates and passes back texture formats.
|
|
//
|
|
// If the structures are succesfully created the internal pointers
|
|
// (lpD3DGlobalDriverData, lpD3DHALCallbacks and (maybe) lpD3DBufCallbacks)
|
|
// are updated to point to valid data structures.
|
|
//
|
|
//-----------------------------------------------------------------------------
|
|
void
|
|
_D3DHALCreateDriver(P3_THUNKEDDATA *pThisDisplay)
|
|
{
|
|
BOOL bRet;
|
|
ULONG Result;
|
|
D3DHAL_GLOBALDRIVERDATA* pD3DDriverData = NULL;
|
|
D3DHAL_CALLBACKS* pD3DHALCallbacks = NULL;
|
|
DDHAL_D3DBUFCALLBACKS* pD3DBufCallbacks = NULL;
|
|
|
|
DBG_ENTRY(_D3DHALCreateDriver);
|
|
|
|
// Verify if we have already created the necessary data. If so, don't go
|
|
// again through this process.
|
|
if ((pThisDisplay->lpD3DGlobalDriverData != 0) &&
|
|
(pThisDisplay->lpD3DHALCallbacks != 0))
|
|
{
|
|
DISPDBG((WRNLVL,"D3D Data already created for this PDEV, "
|
|
"not doing it again."));
|
|
|
|
// we keep the same structure pointers to previously
|
|
// created and stored in pThisDisplay
|
|
|
|
DBG_EXIT(_D3DHALCreateDriver, 0);
|
|
return;
|
|
}
|
|
else
|
|
{
|
|
DISPDBG((WRNLVL,"Creating D3D caps/callbacks for the "
|
|
"first time on this PDEV"));
|
|
}
|
|
|
|
// We set the structure pointers to NULL in case an error happens and
|
|
// we're forced to disable D3D support
|
|
pThisDisplay->lpD3DGlobalDriverData = 0;
|
|
pThisDisplay->lpD3DHALCallbacks = 0;
|
|
pThisDisplay->lpD3DBufCallbacks = 0;
|
|
|
|
// Initialize the context handle data structures (array) . We are careful
|
|
// not to initialize the data structures twice (as between mode changes,
|
|
// for example) as this info needs to be persistent between such events.
|
|
_D3D_CTX_HandleInitialization();
|
|
|
|
//-----------------------------------
|
|
// Allocate necessary data structures
|
|
//-----------------------------------
|
|
|
|
// Initialize our pointers to global driver
|
|
// data and to HAL callbacks to NULL
|
|
pThisDisplay->pD3DDriverData16 = 0;
|
|
pThisDisplay->pD3DDriverData32 = 0;
|
|
|
|
pThisDisplay->pD3DHALCallbacks16 = 0;
|
|
pThisDisplay->pD3DHALCallbacks32 = 0;
|
|
|
|
pThisDisplay->pD3DHALExecuteCallbacks16 = 0;
|
|
pThisDisplay->pD3DHALExecuteCallbacks32 = 0;
|
|
|
|
// Allocate memory for the global driver data structure.
|
|
SHARED_HEAP_ALLOC(&pThisDisplay->pD3DDriverData16,
|
|
&pThisDisplay->pD3DDriverData32,
|
|
sizeof(D3DHAL_GLOBALDRIVERDATA));
|
|
|
|
if (pThisDisplay->pD3DDriverData32 == 0)
|
|
{
|
|
DISPDBG((ERRLVL, "ERROR: _D3DHALCreateDriver: "
|
|
"Failed to allocate driverdata memory"));
|
|
|
|
DBG_EXIT(_D3DHALCreateDriver,0);
|
|
return;
|
|
}
|
|
|
|
DISPDBG((DBGLVL,"Allocated D3DDriverData Memory: p16:0x%x, p32:0x%x",
|
|
pThisDisplay->pD3DDriverData16,
|
|
pThisDisplay->pD3DDriverData32));
|
|
|
|
// Allocate memory for the global HAL callback data structure.
|
|
SHARED_HEAP_ALLOC(&pThisDisplay->pD3DHALCallbacks16,
|
|
&pThisDisplay->pD3DHALCallbacks32,
|
|
sizeof(D3DHAL_CALLBACKS));
|
|
|
|
if (pThisDisplay->pD3DHALCallbacks32 == 0)
|
|
{
|
|
DISPDBG((ERRLVL, "ERROR: _D3DHALCreateDriver: "
|
|
"Failed to allocate callback memory"));
|
|
|
|
SHARED_HEAP_FREE(&pThisDisplay->pD3DDriverData16,
|
|
&pThisDisplay->pD3DDriverData32,
|
|
TRUE);
|
|
|
|
DBG_EXIT(_D3DHALCreateDriver, 0);
|
|
return;
|
|
}
|
|
|
|
DISPDBG((DBGLVL,"Allocated HAL Callbacks Memory: p16:0x%x, p32:0x%x",
|
|
pThisDisplay->pD3DHALCallbacks16,
|
|
pThisDisplay->pD3DHALCallbacks32));
|
|
|
|
// Allocate memory for the global Vertex Buffer callback data structure.
|
|
SHARED_HEAP_ALLOC(&pThisDisplay->pD3DHALExecuteCallbacks16,
|
|
&pThisDisplay->pD3DHALExecuteCallbacks32,
|
|
sizeof(DDHAL_D3DBUFCALLBACKS));
|
|
|
|
if (pThisDisplay->pD3DHALExecuteCallbacks32 == 0)
|
|
{
|
|
DISPDBG((ERRLVL, "ERROR: _D3DHALCreateDriver: "
|
|
"Failed to allocate callback memory"));
|
|
|
|
SHARED_HEAP_FREE(&pThisDisplay->pD3DDriverData16,
|
|
&pThisDisplay->pD3DDriverData32,
|
|
TRUE);
|
|
SHARED_HEAP_FREE(&pThisDisplay->pD3DHALCallbacks16,
|
|
&pThisDisplay->pD3DHALCallbacks32,
|
|
TRUE);
|
|
|
|
DBG_EXIT(_D3DHALCreateDriver, 0);
|
|
return;
|
|
}
|
|
|
|
DISPDBG((DBGLVL,"Allocated Vertex Buffer Callbacks Memory: "
|
|
"p16:0x%x, p32:0x%x",
|
|
pThisDisplay->pD3DHALExecuteCallbacks16,
|
|
pThisDisplay->pD3DHALExecuteCallbacks32));
|
|
|
|
//------------------------------------------------------
|
|
// Fill in the data structures the driver has to provide
|
|
//------------------------------------------------------
|
|
|
|
// Get the Pointers
|
|
pD3DDriverData = (D3DHAL_GLOBALDRIVERDATA*)pThisDisplay->pD3DDriverData32;
|
|
pD3DHALCallbacks = (D3DHAL_CALLBACKS*)pThisDisplay->pD3DHALCallbacks32;
|
|
pD3DBufCallbacks =
|
|
(DDHAL_D3DBUFCALLBACKS *)pThisDisplay->pD3DHALExecuteCallbacks32;
|
|
|
|
// Clear the global data
|
|
memset(pD3DDriverData, 0, sizeof(D3DHAL_GLOBALDRIVERDATA));
|
|
pD3DDriverData->dwSize = sizeof(D3DHAL_GLOBALDRIVERDATA);
|
|
|
|
// Clear the HAL callbacks
|
|
memset(pD3DHALCallbacks, 0, sizeof(D3DHAL_CALLBACKS));
|
|
pD3DHALCallbacks->dwSize = sizeof(D3DHAL_CALLBACKS);
|
|
|
|
// Clear the Vertex Buffer callbacks
|
|
memset(pD3DBufCallbacks, 0, sizeof(DDHAL_D3DBUFCALLBACKS));
|
|
pD3DBufCallbacks->dwSize = sizeof(DDHAL_D3DBUFCALLBACKS);
|
|
|
|
// Report that we can texture from nonlocal vidmem only if the
|
|
// card is an AGP one and AGP is enabed.
|
|
if (pThisDisplay->bCanAGP)
|
|
{
|
|
g_P3RXCaps.dwDevCaps |= D3DDEVCAPS_TEXTURENONLOCALVIDMEM;
|
|
}
|
|
|
|
#if DX7_ANTIALIAS
|
|
// Report we support fullscreen antialiasing
|
|
g_P3RXCaps.dpcTriCaps.dwRasterCaps |=
|
|
#if DX8_DDI
|
|
D3DPRASTERCAPS_STRETCHBLTMULTISAMPLE |
|
|
#endif
|
|
D3DPRASTERCAPS_ANTIALIASSORTINDEPENDENT;
|
|
#endif // DX7_ANTIALIAS
|
|
|
|
#if DX8_3DTEXTURES
|
|
// Report we support 3D textures
|
|
g_P3RXCaps.dpcTriCaps.dwTextureCaps |= D3DPTEXTURECAPS_VOLUMEMAP |
|
|
D3DPTEXTURECAPS_VOLUMEMAP_POW2;
|
|
#endif // DX8_3DTEXTURES
|
|
|
|
//@@BEGIN_DDKSPLIT
|
|
#if DX7_WBUFFER
|
|
g_P3RXCaps.dpcTriCaps.dwRasterCaps |= D3DPRASTERCAPS_WBUFFER;
|
|
#endif // DX7_WBUFFER
|
|
//@@END_DDKSPLIT
|
|
|
|
#if DX8_DDI
|
|
if (TLCHIP_GAMMA)
|
|
{
|
|
// Enable handling of the new D3DRS_COLORWRITEENABLE
|
|
// but only for GVX1 since VX1 has trouble with this at 16bpp
|
|
g_P3RXCaps.dpcTriCaps.dwMiscCaps |= D3DPMISCCAPS_COLORWRITEENABLE;
|
|
g_P3RXCaps.dpcLineCaps.dwMiscCaps |= D3DPMISCCAPS_COLORWRITEENABLE;
|
|
}
|
|
|
|
// Enable new cap for mipmap support
|
|
g_P3RXCaps.dpcTriCaps.dwTextureCaps |= D3DPTEXTURECAPS_MIPMAP;
|
|
g_P3RXCaps.dpcLineCaps.dwTextureCaps |= D3DPTEXTURECAPS_MIPMAP;
|
|
|
|
#endif // DX8_DDI
|
|
|
|
//---------------------------
|
|
// Fill in global driver data
|
|
//---------------------------
|
|
|
|
// Hardware caps supoorted
|
|
pD3DDriverData->dwNumVertices = 0;
|
|
pD3DDriverData->dwNumClipVertices = 0;
|
|
pD3DDriverData->hwCaps = g_P3RXCaps;
|
|
|
|
// Build a table with the texture formats supported. Store in pThisDisplay
|
|
// as we will need this also for DdCanCreateSurface. ( Notice that since
|
|
// _D3DHALCreateDriver will be called in every driver load or mode change,
|
|
// we will have valid TextureFormats in pThisDisplay whenever
|
|
// DdCanCreateSurface is called )
|
|
__D3D_BuildTextureFormatsP3(pThisDisplay,
|
|
&pThisDisplay->TextureFormats[0],
|
|
&pThisDisplay->dwNumTextureFormats);
|
|
|
|
pD3DDriverData->dwNumTextureFormats = pThisDisplay->dwNumTextureFormats;
|
|
pD3DDriverData->lpTextureFormats = pThisDisplay->TextureFormats;
|
|
|
|
//---------------------------------------
|
|
// Fill in context handling HAL callbacks
|
|
//---------------------------------------
|
|
pD3DHALCallbacks->ContextCreate = D3DContextCreate;
|
|
pD3DHALCallbacks->ContextDestroy = D3DContextDestroy;
|
|
|
|
|
|
//---------------------------------------------------
|
|
// Fill in Vertex Buffer callbacks pointers and flags
|
|
//---------------------------------------------------
|
|
|
|
#if !DX7_VERTEXBUFFERS
|
|
// We won't use this structure at all so delete it
|
|
SHARED_HEAP_FREE(&pThisDisplay->pD3DHALExecuteCallbacks16,
|
|
&pThisDisplay->pD3DHALExecuteCallbacks32,
|
|
TRUE);
|
|
pD3DBufCallbacks = NULL;
|
|
//@@BEGIN_DDKSPLIT
|
|
#else
|
|
pD3DBufCallbacks->dwSize = sizeof(DDHAL_D3DBUFCALLBACKS);
|
|
pD3DBufCallbacks->dwFlags = DDHAL_EXEBUFCB32_CANCREATEEXEBUF |
|
|
DDHAL_EXEBUFCB32_CREATEEXEBUF |
|
|
DDHAL_EXEBUFCB32_DESTROYEXEBUF |
|
|
DDHAL_EXEBUFCB32_LOCKEXEBUF |
|
|
DDHAL_EXEBUFCB32_UNLOCKEXEBUF;
|
|
#if WNT_DDRAW
|
|
// Execute buffer callbacks for WinNT
|
|
pD3DBufCallbacks->CanCreateD3DBuffer = D3DCanCreateD3DBuffer;
|
|
pD3DBufCallbacks->CreateD3DBuffer = D3DCreateD3DBuffer;
|
|
pD3DBufCallbacks->DestroyD3DBuffer = D3DDestroyD3DBuffer;
|
|
pD3DBufCallbacks->LockD3DBuffer = D3DLockD3DBuffer;
|
|
pD3DBufCallbacks->UnlockD3DBuffer = D3DUnlockD3DBuffer;
|
|
#else
|
|
|
|
// Execute buffer callbacks for Win9x
|
|
pD3DBufCallbacks->CanCreateExecuteBuffer = D3DCanCreateD3DBuffer;
|
|
pD3DBufCallbacks->CreateExecuteBuffer = D3DCreateD3DBuffer;
|
|
pD3DBufCallbacks->DestroyExecuteBuffer = D3DDestroyD3DBuffer;
|
|
pD3DBufCallbacks->LockExecuteBuffer = D3DLockD3DBuffer;
|
|
pD3DBufCallbacks->UnlockExecuteBuffer = D3DUnlockD3DBuffer;
|
|
|
|
#endif // WNT_DDRAW
|
|
//@@END_DDKSPLIT
|
|
|
|
#endif // DX7_VERTEXBUFFERS
|
|
|
|
//---------------------------------------------------------
|
|
// We return with updated pThisDisplay internal pointers to
|
|
// the driver data, HAL and Vertex Buffer structures.
|
|
//---------------------------------------------------------
|
|
pThisDisplay->lpD3DGlobalDriverData = (ULONG_PTR)pD3DDriverData;
|
|
pThisDisplay->lpD3DHALCallbacks = (ULONG_PTR)pD3DHALCallbacks;
|
|
pThisDisplay->lpD3DBufCallbacks = (ULONG_PTR)pD3DBufCallbacks;
|
|
|
|
#ifndef WNT_DDRAW
|
|
|
|
//
|
|
// Set up the same information in DDHALINFO
|
|
//
|
|
|
|
//@@BEGIN_DDKSPLIT
|
|
#ifdef W95_DDRAW
|
|
|
|
//
|
|
// Our {in|ex}ternal header files are not completely consistent regarding
|
|
// these 2 callback functions, internally they are typed function pointers,
|
|
// externally they are just DWORDs.
|
|
//
|
|
|
|
pThisDisplay->ddhi32.lpD3DGlobalDriverData = pD3DDriverData;
|
|
pThisDisplay->ddhi32.lpD3DHALCallbacks = pD3DHALCallbacks;
|
|
#else
|
|
//@@END_DDKSPLIT
|
|
pThisDisplay->ddhi32.lpD3DGlobalDriverData = (ULONG_PTR)pD3DDriverData;
|
|
pThisDisplay->ddhi32.lpD3DHALCallbacks = (ULONG_PTR)pD3DHALCallbacks;
|
|
//@@BEGIN_DDKSPLIT
|
|
#endif
|
|
//@@END_DDKSPLIT
|
|
pThisDisplay->ddhi32.lpDDExeBufCallbacks = pD3DBufCallbacks;
|
|
|
|
#endif
|
|
|
|
DBG_EXIT(_D3DHALCreateDriver,0);
|
|
return;
|
|
} // _D3DHALCreateDriver
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//
|
|
// void _D3DGetDriverInfo
|
|
//
|
|
// _D3DGetDriverInfo is a helper function called by DdGetDriverInfo , not a
|
|
// callback. Its main purpouse is to centralize the second part of D3D
|
|
// initialization (the first part is handled by _D3DHALCreateDriver) .
|
|
//
|
|
// _D3DGetDriverInfo handles the
|
|
//
|
|
// GUID_D3DExtendedCaps
|
|
// GUID_D3DParseUnknownCommandCallback
|
|
// GUID_D3DCallbacks3
|
|
// GUID_ZPixelFormats
|
|
// GUID_Miscellaneous2Callbacks
|
|
//
|
|
// GUIDs and fills all the relevant information associated to them.
|
|
// GUID_D3DCallbacks2 is not handled at all because it is a legacy GUID.
|
|
//
|
|
//-----------------------------------------------------------------------------
|
|
void
|
|
_D3DGetDriverInfo(
|
|
LPDDHAL_GETDRIVERINFODATA lpData)
|
|
{
|
|
DWORD dwSize;
|
|
P3_THUNKEDDATA *pThisDisplay;
|
|
|
|
DBG_ENTRY(_D3DGetDriverInfo);
|
|
|
|
// Get a pointer to the chip we are on.
|
|
|
|
#if WNT_DDRAW
|
|
pThisDisplay = (P3_THUNKEDDATA*)(((PPDEV)(lpData->dhpdev))->thunkData);
|
|
#else
|
|
pThisDisplay = (P3_THUNKEDDATA*)lpData->dwContext;
|
|
if (! pThisDisplay)
|
|
{
|
|
pThisDisplay = g_pDriverData;
|
|
}
|
|
#endif
|
|
|
|
// Fill in required Miscellaneous2 callbacks
|
|
if ( MATCH_GUID(lpData->guidInfo, GUID_Miscellaneous2Callbacks))
|
|
{
|
|
DDHAL_DDMISCELLANEOUS2CALLBACKS DDMisc2;
|
|
|
|
DISPDBG((DBGLVL, " GUID_Miscellaneous2Callbacks"));
|
|
|
|
memset(&DDMisc2, 0, sizeof(DDMisc2));
|
|
|
|
dwSize = min(lpData->dwExpectedSize,
|
|
sizeof(DDHAL_DDMISCELLANEOUS2CALLBACKS));
|
|
lpData->dwActualSize = sizeof(DDHAL_DDMISCELLANEOUS2CALLBACKS);
|
|
|
|
ASSERTDD((lpData->dwExpectedSize ==
|
|
sizeof(DDHAL_DDMISCELLANEOUS2CALLBACKS)),
|
|
"ERROR: Callbacks 2 size incorrect!");
|
|
|
|
DDMisc2.dwSize = dwSize;
|
|
DDMisc2.dwFlags = DDHAL_MISC2CB32_GETDRIVERSTATE |
|
|
DDHAL_MISC2CB32_CREATESURFACEEX |
|
|
DDHAL_MISC2CB32_DESTROYDDLOCAL;
|
|
|
|
DDMisc2.GetDriverState = D3DGetDriverState;
|
|
DDMisc2.CreateSurfaceEx = D3DCreateSurfaceEx;
|
|
DDMisc2.DestroyDDLocal = D3DDestroyDDLocal;
|
|
|
|
memcpy(lpData->lpvData, &DDMisc2, dwSize);
|
|
lpData->ddRVal = DD_OK;
|
|
}
|
|
|
|
// Fill in the extended caps
|
|
if (MATCH_GUID((lpData->guidInfo), GUID_D3DExtendedCaps) )
|
|
{
|
|
DISPDBG((DBGLVL, " GUID_D3DExtendedCaps"));
|
|
dwSize = min(lpData->dwExpectedSize, sizeof(D3DHAL_D3DEXTENDEDCAPS));
|
|
|
|
lpData->dwActualSize = sizeof(D3DHAL_D3DEXTENDEDCAPS);
|
|
|
|
memcpy(lpData->lpvData, &gc_D3DEC, sizeof(gc_D3DEC) );
|
|
lpData->ddRVal = DD_OK;
|
|
}
|
|
|
|
// Grab the pointer to the ParseUnknownCommand OS callback
|
|
if ( MATCH_GUID(lpData->guidInfo, GUID_D3DParseUnknownCommandCallback) )
|
|
{
|
|
DISPDBG((DBGLVL, "Get D3DParseUnknownCommandCallback"));
|
|
|
|
*(ULONG_PTR *)(&pThisDisplay->pD3DParseUnknownCommand) =
|
|
(ULONG_PTR)lpData->lpvData;
|
|
|
|
ASSERTDD((pThisDisplay->pD3DParseUnknownCommand),
|
|
"D3D ParseUnknownCommand callback == NULL");
|
|
|
|
lpData->ddRVal = DD_OK;
|
|
}
|
|
|
|
// Fill in ZBuffer/Stencil formats supported. If you don't respond to
|
|
// this GUID, ZBuffer formats will be inferred from the D3DDEVICEDESC
|
|
// copied in _D3DHALCreateDriver
|
|
if ( MATCH_GUID(lpData->guidInfo, GUID_ZPixelFormats))
|
|
{
|
|
DISPDBG((DBGLVL, " GUID_ZPixelFormats"));
|
|
|
|
dwSize = min(lpData->dwExpectedSize, sizeof(P3RXZFormats));
|
|
lpData->dwActualSize = sizeof(P3RXZFormats);
|
|
memcpy(lpData->lpvData, &P3RXZFormats, dwSize);
|
|
|
|
lpData->ddRVal = DD_OK;
|
|
}
|
|
|
|
// Fill in required D3DCallbacks3 callbacks
|
|
if ( MATCH_GUID(lpData->guidInfo, GUID_D3DCallbacks3) )
|
|
{
|
|
D3DHAL_CALLBACKS3 D3DCallbacks3;
|
|
memset(&D3DCallbacks3, 0, sizeof(D3DCallbacks3));
|
|
|
|
DISPDBG((DBGLVL, " GUID_D3DCallbacks3"));
|
|
dwSize = min(lpData->dwExpectedSize, sizeof(D3DHAL_CALLBACKS3));
|
|
lpData->dwActualSize = sizeof(D3DHAL_CALLBACKS3);
|
|
|
|
ASSERTDD((lpData->dwExpectedSize == sizeof(D3DHAL_CALLBACKS3)),
|
|
"ERROR: Callbacks 3 size incorrect!");
|
|
|
|
D3DCallbacks3.dwSize = dwSize;
|
|
D3DCallbacks3.dwFlags = D3DHAL3_CB32_VALIDATETEXTURESTAGESTATE |
|
|
D3DHAL3_CB32_DRAWPRIMITIVES2;
|
|
|
|
D3DCallbacks3.DrawPrimitives2 = D3DDrawPrimitives2_P3;
|
|
D3DCallbacks3.ValidateTextureStageState = D3DValidateDeviceP3;
|
|
|
|
memcpy(lpData->lpvData, &D3DCallbacks3, dwSize);
|
|
lpData->ddRVal = DD_OK;
|
|
}
|
|
|
|
// Check for calls to GetDriverInfo2
|
|
// Notice : GUID_GetDriverInfo2 has the same value as GUID_DDStereoMode
|
|
#if DX8_DDI
|
|
if ( MATCH_GUID(lpData->guidInfo, GUID_GetDriverInfo2) )
|
|
#else
|
|
if ( MATCH_GUID(lpData->guidInfo, GUID_DDStereoMode) )
|
|
#endif
|
|
{
|
|
#if DX8_DDI
|
|
// Make sure this is actually a call to GetDriverInfo2
|
|
// ( and not a call to DDStereoMode!)
|
|
if (D3DGDI_IS_GDI2(lpData))
|
|
{
|
|
// Yes, its a call to GetDriverInfo2, fetch the
|
|
// DD_GETDRIVERINFO2DATA data structure.
|
|
DD_GETDRIVERINFO2DATA* pgdi2 = D3DGDI_GET_GDI2_DATA(lpData);
|
|
DD_GETFORMATCOUNTDATA* pgfcd;
|
|
DD_GETFORMATDATA* pgfd;
|
|
DD_DXVERSION* pdxv;
|
|
|
|
// What type of request is this?
|
|
switch (pgdi2->dwType)
|
|
{
|
|
case D3DGDI2_TYPE_DXVERSION:
|
|
// This is a way for a driver on NT to find out the DX-Runtime
|
|
// version. This information is provided to a new driver (i.e.
|
|
// one that exposes GETDRIVERINFO2) for DX7 applications and
|
|
// DX8 applications. And you should get x0000800 for
|
|
// dwDXVersion; or more accurately, you should get
|
|
// DD_RUNTIME_VERSION which is defined in ddrawi.h.
|
|
pdxv = (DD_DXVERSION*)pgdi2;
|
|
pThisDisplay->dwDXVersion = pdxv->dwDXVersion;
|
|
lpData->dwActualSize = sizeof(DD_DXVERSION);
|
|
lpData->ddRVal = DD_OK;
|
|
break;
|
|
|
|
case D3DGDI2_TYPE_GETFORMATCOUNT:
|
|
{
|
|
// Its a request for the number of texture formats
|
|
// we support. Get the extended data structure so
|
|
// we can fill in the format count field.
|
|
pgfcd = (DD_GETFORMATCOUNTDATA*)pgdi2;
|
|
pgfcd->dwFormatCount = DX8_FORMAT_COUNT;
|
|
lpData->dwActualSize = sizeof(DD_GETFORMATCOUNTDATA);
|
|
lpData->ddRVal = DD_OK;
|
|
}
|
|
break;
|
|
|
|
case D3DGDI2_TYPE_GETFORMAT:
|
|
{
|
|
// Its a request for a particular format we support.
|
|
// Get the extended data structure so we can fill in
|
|
// the format field.
|
|
pgfd = (DD_GETFORMATDATA*)pgdi2;
|
|
|
|
// Initialize the surface description and copy over
|
|
// the pixel format from out pixel format table.
|
|
memcpy(&pgfd->format,
|
|
&DX8FormatTable[pgfd->dwFormatIndex],
|
|
sizeof(pgfd->format));
|
|
lpData->dwActualSize = sizeof(DD_GETFORMATDATA);
|
|
lpData->ddRVal = DD_OK;
|
|
}
|
|
break;
|
|
|
|
case D3DGDI2_TYPE_GETD3DCAPS8:
|
|
{
|
|
// The runtime is requesting the DX8 D3D caps
|
|
|
|
int i;
|
|
size_t copySize;
|
|
|
|
// We will populate this caps as much as we can
|
|
// from the DX7 caps structure(s). ( We need anyway
|
|
// to be able to report DX7 caps for DX7 apps )
|
|
__D3D_Fill_DX8Caps(&g_P3RX_D3DCaps8,
|
|
&g_P3RXCaps,
|
|
&gc_D3DEC,
|
|
&pThisDisplay->ddhi32);
|
|
|
|
// And now we fill anything that might not be there
|
|
// These fields are new and absent from any other legacy
|
|
// structure
|
|
|
|
g_P3RX_D3DCaps8.DeviceType = D3DDEVTYPE_HAL; // Device Info
|
|
g_P3RX_D3DCaps8.AdapterOrdinal = 0;
|
|
|
|
#if DX_NOT_SUPPORTED_FEATURE
|
|
// NOTE: In some beta releases of this sample driver we
|
|
// used to setup bit caps for using it as a pure
|
|
// device (D3DDEVCAPS_PUREDEVICE). On the final
|
|
// DX8 release pure devices are not allowed on
|
|
// non-TnL/non hwvp parts as they don't give any
|
|
// real advantage over non-pure ones.
|
|
|
|
g_P3RX_D3DCaps8.DevCaps |= D3DDEVCAPS_PUREDEVICE;
|
|
#endif
|
|
|
|
#if DX8_3DTEXTURES
|
|
// On Windows XP the ability to lock just a subvolume of a
|
|
// volume texture has been introduced in DX8.1 (Windows 2000
|
|
// will ignore it)
|
|
g_P3RX_D3DCaps8.DevCaps |= D3DDEVCAPS_SUBVOLUMELOCK;
|
|
#endif // DX8_3DTEXTURES
|
|
|
|
// Indicating that the GDI part of the driver can change
|
|
// gamma ramp while running in full-screen mode.
|
|
g_P3RX_D3DCaps8.Caps2 |= D3DCAPS2_FULLSCREENGAMMA;
|
|
|
|
// The following field can/should be left as 0 as the
|
|
// runtime will field them by itself.
|
|
g_P3RX_D3DCaps8.Caps3 = 0;
|
|
g_P3RX_D3DCaps8.PresentationIntervals = 0;
|
|
|
|
#if DX_NOT_SUPPORTED_FEATURE
|
|
// If your hw/driver supports colored cursor without
|
|
// limitations then set these caps as below. We don't
|
|
// do this in our driver because we have a hw limitation
|
|
// of 16 colors on the cursor. WHQL tests therefore
|
|
// fail because of this limitation
|
|
g_P3RX_D3DCaps8.CursorCaps = D3DCURSORCAPS_COLOR;
|
|
|
|
// Signal that the driver does support hw cursors
|
|
// both for hi resolution modes ( height >= 400) and
|
|
// for low resolution modes as well.
|
|
g_P3RX_D3DCaps8.CursorCaps |= D3DCURSORCAPS_LOWRES;
|
|
#else
|
|
// We have some limitations (read above) in the Perm3
|
|
// hardware so we're not supporting these caps here
|
|
g_P3RX_D3DCaps8.CursorCaps = 0;
|
|
#endif
|
|
// Miscellanneous settings new DX8 features as
|
|
// pointsprites, multistreaming, 3D textures,
|
|
// pixelshaders and vertex shaders
|
|
g_P3RX_D3DCaps8.MaxVertexIndex = 0x000FFFFF;
|
|
|
|
#if DX8_POINTSPRITES
|
|
// Notify we can handle pointsprite size
|
|
g_P3RX_D3DCaps8.FVFCaps |= D3DFVFCAPS_PSIZE;
|
|
// Notice that the MaxPointSize has to be at least 16
|
|
// per the DX8 specification for pointsprites.
|
|
g_P3RX_D3DCaps8.MaxPointSize = P3_MAX_POINTSPRITE_SIZE;
|
|
#endif
|
|
|
|
// Any DX8 driver must declare it suppports
|
|
// AT LEAST 1 stream. Otherwise its used as a DX7 driver.
|
|
g_P3RX_D3DCaps8.MaxStreams = 1;
|
|
|
|
g_P3RX_D3DCaps8.MaxVertexBlendMatrixIndex = 0;
|
|
|
|
// NOTE: It is essential that the macros D3DVS_VERSION
|
|
// and D3DPS_VERSION be used to intialize the vertex
|
|
// and pixel shader version respecitively. The format
|
|
// of the version DWORD is complex so please don't try
|
|
// and build the version DWORD manually.
|
|
g_P3RX_D3DCaps8.VertexShaderVersion = D3DVS_VERSION(0, 0);
|
|
g_P3RX_D3DCaps8.PixelShaderVersion = D3DPS_VERSION(0, 0);
|
|
|
|
#if DX8_3DTEXTURES
|
|
g_P3RX_D3DCaps8.MaxVolumeExtent = 2048;
|
|
#endif
|
|
|
|
// D3DPTFILTERCAPS for IDirect3DCubeTexture8's
|
|
g_P3RX_D3DCaps8.CubeTextureFilterCaps = 0;
|
|
|
|
// D3DLINECAPS
|
|
g_P3RX_D3DCaps8.LineCaps = D3DLINECAPS_TEXTURE |
|
|
D3DLINECAPS_ZTEST |
|
|
D3DLINECAPS_BLEND |
|
|
D3DLINECAPS_ALPHACMP |
|
|
D3DLINECAPS_FOG;
|
|
|
|
// max number of primitives per DrawPrimitive call
|
|
g_P3RX_D3DCaps8.MaxPrimitiveCount = 0x000FFFFF;
|
|
// max value of pixel shade
|
|
g_P3RX_D3DCaps8.MaxPixelShaderValue = 0;
|
|
// max stride for SetStreamSource
|
|
// we will use this defualt value for now
|
|
g_P3RX_D3DCaps8.MaxStreamStride = 256;
|
|
// number of vertex shader constant
|
|
g_P3RX_D3DCaps8.MaxVertexShaderConst = 0;
|
|
|
|
#if DX8_3DTEXTURES
|
|
g_P3RX_D3DCaps8.VolumeTextureFilterCaps =
|
|
D3DPTFILTERCAPS_MINFPOINT |
|
|
D3DPTFILTERCAPS_MAGFPOINT;
|
|
|
|
g_P3RX_D3DCaps8.VolumeTextureAddressCaps =
|
|
D3DPTADDRESSCAPS_WRAP |
|
|
D3DPTADDRESSCAPS_MIRROR |
|
|
D3DPTADDRESSCAPS_CLAMP;
|
|
#endif // DX8_3DTEXTURES
|
|
|
|
// It should be noted that the dwExpectedSize field
|
|
// of DD_GETDRIVERINFODATA is not used for
|
|
// GetDriverInfo2 calls and should be ignored.
|
|
copySize = min(sizeof(g_P3RX_D3DCaps8),
|
|
pgdi2->dwExpectedSize);
|
|
memcpy(lpData->lpvData, &g_P3RX_D3DCaps8, copySize);
|
|
lpData->dwActualSize = copySize;
|
|
lpData->ddRVal = DD_OK;
|
|
}
|
|
default:
|
|
// Default behavior for any other type.
|
|
break;
|
|
}
|
|
}
|
|
else
|
|
#endif // DX8_DDI
|
|
{
|
|
#if WNT_DDRAW
|
|
#if DX7_STEREO
|
|
PDD_STEREOMODE pDDStereoMode;
|
|
|
|
// Permedia3 supports all modes as stereo modes.
|
|
// for test purposes, we restrict them to something
|
|
// larger than 320x240
|
|
|
|
//
|
|
// note: this GUID_DDStereoMode is only used on NT to
|
|
// report stereo modes. There is no need to implement
|
|
// it in win9x drivers. Win9x drivers report stereo
|
|
// modes by setting the DDMODEINFO_STEREO bit in the
|
|
// dwFlags member of the DDHALMODEINFO structure.
|
|
// It is also recommended to report DDMODEINFO_MAXREFRESH
|
|
// for stereo modes when running under a runtime >= DX7 to
|
|
// allow applications to select higher refresh rates for
|
|
// stereo modes.
|
|
//
|
|
|
|
if (lpData->dwExpectedSize >= sizeof(PDD_STEREOMODE))
|
|
{
|
|
pDDStereoMode = (PDD_STEREOMODE)lpData->lpvData;
|
|
|
|
pDDStereoMode->bSupported =
|
|
_DD_bIsStereoMode(pThisDisplay,
|
|
pDDStereoMode->dwWidth,
|
|
pDDStereoMode->dwHeight,
|
|
pDDStereoMode->dwBpp);
|
|
|
|
DISPDBG((DBGLVL," GUID_DDStereoMode(%d,%d,%d,%d=%d)",
|
|
pDDStereoMode->dwWidth,
|
|
pDDStereoMode->dwHeight,
|
|
pDDStereoMode->dwBpp,
|
|
pDDStereoMode->dwRefreshRate,
|
|
pDDStereoMode->bSupported));
|
|
|
|
lpData->dwActualSize = sizeof(DD_STEREOMODE);
|
|
lpData->ddRVal = DD_OK;
|
|
}
|
|
#endif // DX7_STEREO
|
|
#endif // WNT_DDRAW
|
|
}
|
|
}
|
|
|
|
DBG_EXIT(_D3DGetDriverInfo, 0);
|
|
|
|
} // _D3DGetDriverInfo
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//
|
|
// __D3D_BuildTextureFormatsP3
|
|
//
|
|
// Fills a list of texture formats in.
|
|
// Returns the number of formats specified.
|
|
//
|
|
//-----------------------------------------------------------------------------
|
|
void
|
|
__D3D_BuildTextureFormatsP3(
|
|
P3_THUNKEDDATA *pThisDisplay,
|
|
DDSURFACEDESC TexFmt[MAX_TEXTURE_FORMAT],
|
|
DWORD *pNumTextures)
|
|
{
|
|
int i;
|
|
|
|
// Initialise the defaults
|
|
for (i = 0; i < MAX_TEXTURE_FORMAT; i++)
|
|
{
|
|
TexFmt[i].dwSize = sizeof(DDSURFACEDESC);
|
|
TexFmt[i].dwFlags = DDSD_CAPS | DDSD_PIXELFORMAT;
|
|
TexFmt[i].dwHeight = 0;
|
|
TexFmt[i].dwWidth = 0;
|
|
TexFmt[i].lPitch = 0;
|
|
TexFmt[i].dwBackBufferCount = 0;
|
|
TexFmt[i].dwZBufferBitDepth = 0;
|
|
TexFmt[i].dwReserved = 0;
|
|
TexFmt[i].lpSurface = 0;
|
|
|
|
TexFmt[i].ddckCKDestOverlay.dwColorSpaceLowValue = 0;
|
|
TexFmt[i].ddckCKDestOverlay.dwColorSpaceHighValue = 0;
|
|
|
|
TexFmt[i].ddckCKDestBlt.dwColorSpaceLowValue = 0;
|
|
TexFmt[i].ddckCKDestBlt.dwColorSpaceHighValue = 0;
|
|
|
|
TexFmt[i].ddckCKSrcOverlay.dwColorSpaceLowValue = 0;
|
|
TexFmt[i].ddckCKSrcOverlay.dwColorSpaceHighValue = 0;
|
|
|
|
TexFmt[i].ddckCKSrcBlt.dwColorSpaceLowValue = 0;
|
|
TexFmt[i].ddckCKSrcBlt.dwColorSpaceHighValue = 0;
|
|
TexFmt[i].ddsCaps.dwCaps = DDSCAPS_TEXTURE;
|
|
}
|
|
i = 0;
|
|
|
|
// 5:5:5 RGB
|
|
ZeroMemory(&TexFmt[i].ddpfPixelFormat, sizeof(DDPIXELFORMAT));
|
|
TexFmt[i].ddpfPixelFormat.dwSize = sizeof(DDPIXELFORMAT);
|
|
TexFmt[i].ddpfPixelFormat.dwFourCC = 0;
|
|
TexFmt[i].ddpfPixelFormat.dwFlags = DDPF_RGB;
|
|
TexFmt[i].ddpfPixelFormat.dwRGBBitCount = 16;
|
|
TexFmt[i].ddpfPixelFormat.dwRBitMask = 0x7C00;
|
|
TexFmt[i].ddpfPixelFormat.dwGBitMask = 0x03E0;
|
|
TexFmt[i].ddpfPixelFormat.dwBBitMask = 0x001F;
|
|
TexFmt[i].ddpfPixelFormat.dwRGBAlphaBitMask = 0;
|
|
i++;
|
|
|
|
// 8:8:8 RGB
|
|
ZeroMemory(&TexFmt[i].ddpfPixelFormat, sizeof(DDPIXELFORMAT));
|
|
TexFmt[i].ddpfPixelFormat.dwSize = sizeof(DDPIXELFORMAT);
|
|
TexFmt[i].ddpfPixelFormat.dwFourCC = 0;
|
|
TexFmt[i].ddpfPixelFormat.dwFlags = DDPF_RGB;
|
|
TexFmt[i].ddpfPixelFormat.dwRGBBitCount = 32;
|
|
TexFmt[i].ddpfPixelFormat.dwRBitMask = 0xff0000;
|
|
TexFmt[i].ddpfPixelFormat.dwGBitMask = 0xff00;
|
|
TexFmt[i].ddpfPixelFormat.dwBBitMask = 0xff;
|
|
TexFmt[i].ddpfPixelFormat.dwRGBAlphaBitMask = 0;
|
|
i++;
|
|
|
|
// 1:5:5:5 ARGB
|
|
ZeroMemory(&TexFmt[i].ddpfPixelFormat, sizeof(DDPIXELFORMAT));
|
|
TexFmt[i].ddpfPixelFormat.dwSize = sizeof(DDPIXELFORMAT);
|
|
TexFmt[i].ddpfPixelFormat.dwFourCC = 0;
|
|
TexFmt[i].ddpfPixelFormat.dwFlags = DDPF_RGB | DDPF_ALPHAPIXELS;
|
|
TexFmt[i].ddpfPixelFormat.dwRGBBitCount = 16;
|
|
TexFmt[i].ddpfPixelFormat.dwRBitMask = 0x7C00;
|
|
TexFmt[i].ddpfPixelFormat.dwGBitMask = 0x03E0;
|
|
TexFmt[i].ddpfPixelFormat.dwBBitMask = 0x001F;
|
|
TexFmt[i].ddpfPixelFormat.dwRGBAlphaBitMask = 0x8000;
|
|
i++;
|
|
|
|
// 4:4:4:4 ARGB
|
|
ZeroMemory(&TexFmt[i].ddpfPixelFormat, sizeof(DDPIXELFORMAT));
|
|
TexFmt[i].ddpfPixelFormat.dwSize = sizeof(DDPIXELFORMAT);
|
|
TexFmt[i].ddpfPixelFormat.dwFourCC = 0;
|
|
TexFmt[i].ddpfPixelFormat.dwFlags = DDPF_RGB | DDPF_ALPHAPIXELS;
|
|
TexFmt[i].ddpfPixelFormat.dwRGBBitCount = 16;
|
|
TexFmt[i].ddpfPixelFormat.dwRBitMask = 0xf00;
|
|
TexFmt[i].ddpfPixelFormat.dwGBitMask = 0xf0;
|
|
TexFmt[i].ddpfPixelFormat.dwBBitMask = 0xf;
|
|
TexFmt[i].ddpfPixelFormat.dwRGBAlphaBitMask = 0xf000;
|
|
i++;
|
|
|
|
// 8:8:8:8 ARGB
|
|
ZeroMemory(&TexFmt[i].ddpfPixelFormat, sizeof(DDPIXELFORMAT));
|
|
TexFmt[i].ddpfPixelFormat.dwSize = sizeof(DDPIXELFORMAT);
|
|
TexFmt[i].ddpfPixelFormat.dwFourCC = 0;
|
|
TexFmt[i].ddpfPixelFormat.dwFlags = DDPF_RGB | DDPF_ALPHAPIXELS;
|
|
TexFmt[i].ddpfPixelFormat.dwRGBBitCount = 32;
|
|
TexFmt[i].ddpfPixelFormat.dwRBitMask = 0xff0000;
|
|
TexFmt[i].ddpfPixelFormat.dwGBitMask = 0xff00;
|
|
TexFmt[i].ddpfPixelFormat.dwBBitMask = 0xff;
|
|
TexFmt[i].ddpfPixelFormat.dwRGBAlphaBitMask = 0xff000000;
|
|
i++;
|
|
|
|
// 5:6:5
|
|
ZeroMemory(&TexFmt[i].ddpfPixelFormat, sizeof(DDPIXELFORMAT));
|
|
TexFmt[i].ddpfPixelFormat.dwSize = sizeof(DDPIXELFORMAT);
|
|
TexFmt[i].ddpfPixelFormat.dwFourCC = 0;
|
|
TexFmt[i].ddpfPixelFormat.dwFlags = DDPF_RGB;
|
|
TexFmt[i].ddpfPixelFormat.dwRGBBitCount = 16;
|
|
TexFmt[i].ddpfPixelFormat.dwRBitMask = 0xF800;
|
|
TexFmt[i].ddpfPixelFormat.dwGBitMask = 0x07E0;
|
|
TexFmt[i].ddpfPixelFormat.dwBBitMask = 0x001F;
|
|
TexFmt[i].ddpfPixelFormat.dwRGBAlphaBitMask = 0;
|
|
i++;
|
|
|
|
// A4L4
|
|
ZeroMemory(&TexFmt[i].ddpfPixelFormat, sizeof(DDPIXELFORMAT));
|
|
TexFmt[i].ddpfPixelFormat.dwSize = sizeof(DDPIXELFORMAT);
|
|
TexFmt[i].ddpfPixelFormat.dwFourCC = 0;
|
|
TexFmt[i].ddpfPixelFormat.dwFlags = DDPF_LUMINANCE | DDPF_ALPHAPIXELS;
|
|
TexFmt[i].ddpfPixelFormat.dwLuminanceBitCount = 8;
|
|
TexFmt[i].ddpfPixelFormat.dwLuminanceBitMask = 0x0F;
|
|
TexFmt[i].ddpfPixelFormat.dwLuminanceAlphaBitMask = 0xF0;
|
|
i++;
|
|
|
|
// A8L8
|
|
ZeroMemory(&TexFmt[i].ddpfPixelFormat, sizeof(DDPIXELFORMAT));
|
|
TexFmt[i].ddpfPixelFormat.dwSize = sizeof(DDPIXELFORMAT);
|
|
TexFmt[i].ddpfPixelFormat.dwFourCC = 0;
|
|
TexFmt[i].ddpfPixelFormat.dwFlags = DDPF_LUMINANCE | DDPF_ALPHAPIXELS;
|
|
TexFmt[i].ddpfPixelFormat.dwLuminanceBitCount = 16;
|
|
TexFmt[i].ddpfPixelFormat.dwLuminanceBitMask = 0x00FF;
|
|
TexFmt[i].ddpfPixelFormat.dwLuminanceAlphaBitMask = 0xFF00;
|
|
i++;
|
|
|
|
//@@BEGIN_DDKSPLIT
|
|
#if 0
|
|
// A8
|
|
ZeroMemory(&TexFmt[i].ddpfPixelFormat, sizeof(DDPIXELFORMAT));
|
|
TexFmt[i].ddpfPixelFormat.dwSize = sizeof(DDPIXELFORMAT);
|
|
TexFmt[i].ddpfPixelFormat.dwFourCC = 0;
|
|
TexFmt[i].ddpfPixelFormat.dwFlags = DDPF_ALPHA;
|
|
TexFmt[i].ddpfPixelFormat.dwAlphaBitDepth = 8;
|
|
TexFmt[i].ddpfPixelFormat.dwRGBAlphaBitMask = 0xFF;
|
|
i++;
|
|
#endif
|
|
//@@END_DDKSPLIT
|
|
|
|
// L8
|
|
ZeroMemory(&TexFmt[i].ddpfPixelFormat, sizeof(DDPIXELFORMAT));
|
|
TexFmt[i].ddpfPixelFormat.dwSize = sizeof(DDPIXELFORMAT);
|
|
TexFmt[i].ddpfPixelFormat.dwFourCC = 0;
|
|
TexFmt[i].ddpfPixelFormat.dwFlags = DDPF_LUMINANCE;
|
|
TexFmt[i].ddpfPixelFormat.dwLuminanceBitCount = 8;
|
|
TexFmt[i].ddpfPixelFormat.dwLuminanceBitMask = 0xFF;
|
|
TexFmt[i].ddpfPixelFormat.dwLuminanceAlphaBitMask = 0;
|
|
i++;
|
|
|
|
#if DX7_PALETTETEXTURE
|
|
// P8
|
|
ZeroMemory(&TexFmt[i].ddpfPixelFormat, sizeof(DDPIXELFORMAT));
|
|
TexFmt[i].ddpfPixelFormat.dwSize = sizeof(DDPIXELFORMAT);
|
|
TexFmt[i].ddpfPixelFormat.dwFourCC = 0;
|
|
TexFmt[i].ddpfPixelFormat.dwFlags = DDPF_RGB | DDPF_PALETTEINDEXED8;
|
|
TexFmt[i].ddpfPixelFormat.dwRGBBitCount = 8;
|
|
TexFmt[i].ddpfPixelFormat.dwRBitMask = 0x00000000;
|
|
TexFmt[i].ddpfPixelFormat.dwGBitMask = 0x00000000;
|
|
TexFmt[i].ddpfPixelFormat.dwBBitMask = 0x00000000;
|
|
TexFmt[i].ddpfPixelFormat.dwRGBAlphaBitMask = 0x00000000;
|
|
|
|
// Notice we aren't incrementing i for this format. This will effectively
|
|
// cause us to not report the palettized texture format in our DX7 caps
|
|
// list. This is intentional, and driver writers may choose to follow or
|
|
// not this approach. For our DX8 caps list we DO list paletted texture
|
|
// formats as supported. __SUR_bCheckTextureFormat is written to make
|
|
// sure we can create a paletted texture when asked for it.
|
|
|
|
// The whole reason behind this approach is because in legacy DX interfaces
|
|
// the TextureSwap method causes the surface and palette handle association
|
|
// to be lost. While there are some ugly and tricky ways around this (as in
|
|
// the Permedia2 sample driver), and there is no rational way to fix the
|
|
// problem.
|
|
|
|
#endif
|
|
|
|
// Return the number of texture formats to use
|
|
*pNumTextures = i;
|
|
|
|
} // __D3D_BuildTextureFormatsP3
|
|
|
|
#if DX8_DDI
|
|
//-----------------------------------------------------------------------------
|
|
//
|
|
// __D3D_Fill_DX8Caps
|
|
//
|
|
// Fills the D3DCAPS8 structure of a DX8 driver from legacy caps structures.
|
|
//
|
|
//-----------------------------------------------------------------------------
|
|
void
|
|
__D3D_Fill_DX8Caps(
|
|
D3DCAPS8 *pd3d8caps,
|
|
D3DDEVICEDESC_V1 *pDeviceDesc,
|
|
D3DHAL_D3DEXTENDEDCAPS *pD3DEC,
|
|
DDHALINFO *pDDHALInfo)
|
|
{
|
|
|
|
pd3d8caps->Caps = pDDHALInfo->ddCaps.dwCaps;
|
|
pd3d8caps->Caps2 = pDDHALInfo->ddCaps.dwCaps2;
|
|
|
|
pd3d8caps->DevCaps = pDeviceDesc->dwDevCaps;
|
|
|
|
pd3d8caps->PrimitiveMiscCaps = pDeviceDesc->dpcTriCaps.dwMiscCaps;
|
|
pd3d8caps->RasterCaps = pDeviceDesc->dpcTriCaps.dwRasterCaps;
|
|
pd3d8caps->ZCmpCaps = pDeviceDesc->dpcTriCaps.dwZCmpCaps;
|
|
pd3d8caps->SrcBlendCaps = pDeviceDesc->dpcTriCaps.dwSrcBlendCaps;
|
|
pd3d8caps->DestBlendCaps = pDeviceDesc->dpcTriCaps.dwDestBlendCaps;
|
|
pd3d8caps->AlphaCmpCaps = pDeviceDesc->dpcTriCaps.dwAlphaCmpCaps;
|
|
pd3d8caps->ShadeCaps = pDeviceDesc->dpcTriCaps.dwShadeCaps;
|
|
pd3d8caps->TextureCaps = pDeviceDesc->dpcTriCaps.dwTextureCaps;
|
|
pd3d8caps->TextureFilterCaps = pDeviceDesc->dpcTriCaps.dwTextureFilterCaps;
|
|
pd3d8caps->TextureAddressCaps= pDeviceDesc->dpcTriCaps.dwTextureAddressCaps;
|
|
|
|
pd3d8caps->MaxTextureWidth = pD3DEC->dwMaxTextureWidth;
|
|
pd3d8caps->MaxTextureHeight = pD3DEC->dwMaxTextureHeight;
|
|
|
|
pd3d8caps->MaxTextureRepeat = pD3DEC->dwMaxTextureRepeat;
|
|
pd3d8caps->MaxTextureAspectRatio = pD3DEC->dwMaxTextureAspectRatio;
|
|
pd3d8caps->MaxAnisotropy = pD3DEC->dwMaxAnisotropy;
|
|
pd3d8caps->MaxVertexW = pD3DEC->dvMaxVertexW;
|
|
|
|
pd3d8caps->GuardBandLeft = pD3DEC->dvGuardBandLeft;
|
|
pd3d8caps->GuardBandTop = pD3DEC->dvGuardBandTop;
|
|
pd3d8caps->GuardBandRight = pD3DEC->dvGuardBandRight;
|
|
pd3d8caps->GuardBandBottom = pD3DEC->dvGuardBandBottom;
|
|
|
|
pd3d8caps->ExtentsAdjust = pD3DEC->dvExtentsAdjust;
|
|
pd3d8caps->StencilCaps = pD3DEC->dwStencilCaps;
|
|
|
|
pd3d8caps->FVFCaps = pD3DEC->dwFVFCaps;
|
|
pd3d8caps->TextureOpCaps = pD3DEC->dwTextureOpCaps;
|
|
pd3d8caps->MaxTextureBlendStages = pD3DEC->wMaxTextureBlendStages;
|
|
pd3d8caps->MaxSimultaneousTextures = pD3DEC->wMaxSimultaneousTextures;
|
|
|
|
pd3d8caps->VertexProcessingCaps = pD3DEC->dwVertexProcessingCaps;
|
|
pd3d8caps->MaxActiveLights = pD3DEC->dwMaxActiveLights;
|
|
pd3d8caps->MaxUserClipPlanes = pD3DEC->wMaxUserClipPlanes;
|
|
pd3d8caps->MaxVertexBlendMatrices = pD3DEC->wMaxVertexBlendMatrices;
|
|
|
|
} // __D3D_Fill_DX8Caps
|
|
#endif // DX8_DDI
|
|
|