ReactOS Development > Doxygen

00001 #include <d3d9.h>
00002 #include <ddraw.h>
00003 #include <d3dnthal.h>
00004 #include <d3dhal.h>
00005 #include <ddrawi.h>
00006 #include <ddrawgdi.h>
00007 #include <dll/directx/d3d8thk.h>
00008 #include <debug.h>
00009 #include <limits.h>
00010 #include "d3d9_helpers.h"
00011 #include "d3d9_caps.h"
00012 #include "adapter.h"
00013 #include "d3d9_callbacks.h"
00014 
00015 static INT g_NumDevices = 0;
00016 
00017 void CreateDisplayModeList(LPCSTR lpszDeviceName, D3DDISPLAYMODE* pDisplayModes, DWORD* pNumDisplayModes, D3DFORMAT Default16BitFormat, D3D9_Unknown6BC* pUnknown6BC)
00018 {
00019     DEVMODEA DevMode;
00020     DWORD ModeIndex = 0;
00021     DWORD ValidModes = 0;
00022 
00023     while (TRUE == EnumDisplaySettingsA(lpszDeviceName, ModeIndex, &DevMode))
00024     {
00025         D3DFORMAT DefaultFormat;
00026 
00027         if (DevMode.dmBitsPerPel != 15 &&
00028             DevMode.dmBitsPerPel != 16 &&
00029             DevMode.dmBitsPerPel != 32)
00030         {
00031             ++ModeIndex;
00032             continue;
00033         }
00034 
00035         ++ValidModes;
00036 
00037         if (DevMode.dmBitsPerPel == 15 || DevMode.dmBitsPerPel == 16)
00038         {
00039             if (NULL == pUnknown6BC)
00040             {
00041                 ++ModeIndex;
00042                 continue;
00043             }
00044 
00045             DefaultFormat = Default16BitFormat;
00046         }
00047         else
00048         {
00049             DefaultFormat = D3DFMT_X8R8G8B8;
00050         }
00051 
00052         if (NULL != pDisplayModes)
00053         {
00054             if (ValidModes == *pNumDisplayModes)
00055                 break;
00056 
00057             pDisplayModes->Width = DevMode.dmPelsWidth;
00058             pDisplayModes->Height = DevMode.dmPelsHeight;
00059             pDisplayModes->RefreshRate = DevMode.dmDisplayFrequency;
00060             pDisplayModes->Format = DefaultFormat;
00061             ++pDisplayModes;
00062         }
00063 
00064         ++ModeIndex;
00065     }
00066 
00067     *pNumDisplayModes = ValidModes;
00068 }
00069 
00070 static void CreateInternalDeviceData(HDC hDC, LPCSTR lpszDeviceName, D3D9_Unknown6BC** ppUnknown, D3DDEVTYPE DeviceType, HMODULE* hD3DRefDll)
00071 {
00072     D3D9_Unknown6BC* pUnknown6BC;
00073     DWORD ValueSize;
00074 
00075     if (ppUnknown) *ppUnknown = NULL;
00076     if (hD3DRefDll) *hD3DRefDll = NULL;
00077 
00078     if (DeviceType != D3DDEVTYPE_HAL)
00079     {
00080         /* TODO: Implement D3DDEVTYPE_REF and D3DDEVTYPE_SW */
00081         UNIMPLEMENTED;
00082         return;
00083     }
00084 
00085     pUnknown6BC = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(D3D9_Unknown6BC));
00086     if (NULL == pUnknown6BC)
00087     {
00088         DPRINT1("Out of memory");
00089         return;
00090     }
00091 
00092     pUnknown6BC->hDirectDrawLocal = OsThunkDdCreateDirectDrawObject(hDC);
00093     if (0 == pUnknown6BC->hDirectDrawLocal)
00094     {
00095         HeapFree(GetProcessHeap(), 0, pUnknown6BC);
00096         return;
00097     }
00098 
00099 
00100     SafeCopyString(pUnknown6BC->szDeviceName, CCHDEVICENAME, lpszDeviceName);
00101     //pUnknown6BC->DeviceUniq = DdQueryDisplaySettingsUniqueness();
00102     pUnknown6BC->DeviceType = DeviceType;
00103 
00104 
00105     ValueSize = sizeof(DWORD);
00106     ReadRegistryValue(REG_DWORD, "ForceDriverFlagsOn", (LPBYTE)&pUnknown6BC->bForceDriverFlagsOn, &ValueSize);
00107 
00108     ValueSize = sizeof(DWORD);
00109     ReadRegistryValue(REG_DWORD, "ForceDriverFlagsOff", (LPBYTE)&pUnknown6BC->bForceDriverFlagsOff, &ValueSize);
00110 
00111     ++g_NumDevices;
00112 
00113     *ppUnknown = pUnknown6BC;
00114 }
00115 
00116 static void ReleaseInternalDeviceData(LPD3D9_DEVICEDATA pDeviceData)
00117 {
00118     OsThunkDdDeleteDirectDrawObject(pDeviceData->pUnknown6BC->hDirectDrawLocal);
00119 
00120     HeapFree(GetProcessHeap(), 0, pDeviceData->pUnknown6BC);
00121     pDeviceData->pUnknown6BC = NULL;
00122 
00123     --g_NumDevices;
00124 }
00125 
00126 BOOL GetDeviceData(LPD3D9_DEVICEDATA pDeviceData)
00127 {
00128     BOOL bRet;
00129     D3DHAL_GLOBALDRIVERDATA GlobalDriverData;
00130     D3DHAL_D3DEXTENDEDCAPS D3dExtendedCaps;
00131     LPDDSURFACEDESC puD3dTextureFormats;
00132     DDPIXELFORMAT* pD3dZStencilFormatList;
00133     D3DDISPLAYMODE* pD3dDisplayModeList;
00134     D3DQUERYTYPE* pD3dQueryList;
00135     DWORD NumTextureFormats = 0;
00136     DWORD NumStencilFormats = 0;
00137     DWORD NumExtendedFormats = 0;
00138     DWORD NumQueries = 0;
00139 
00140     if (NULL == pDeviceData->pUnknown6BC)
00141     {
00142         CreateInternalDeviceData(
00143             pDeviceData->hDC,
00144             pDeviceData->szDeviceName,
00145             &pDeviceData->pUnknown6BC,
00146             pDeviceData->DeviceType,
00147             &pDeviceData->hD3DRefDll
00148             );
00149 
00150         if (NULL == pDeviceData->pUnknown6BC)
00151         {
00152             DPRINT1("Failed to create DirectDrawObject for Direct3D9");
00153             return FALSE;
00154         }
00155     }
00156     else
00157     {
00158         D3D9_DRIVERCAPS DriverCaps;
00159         D3D9_CALLBACKS D3D9Callbacks;
00160 
00161         if (FALSE == CanReenableDirectDrawObject(pDeviceData->pUnknown6BC))
00162         {
00163             DPRINT1("Failed to re-enable DirectDrawObject");
00164             return FALSE;
00165         }
00166 
00167         bRet = GetD3D9DriverInfo(
00168             pDeviceData->pUnknown6BC,
00169             &DriverCaps,
00170             &D3D9Callbacks,
00171             pDeviceData->szDeviceName,
00172             pDeviceData->hD3DRefDll,
00173             &GlobalDriverData,
00174             &D3dExtendedCaps,
00175             NULL,
00176             NULL,
00177             NULL,
00178             NULL,
00179             &NumTextureFormats,
00180             &NumStencilFormats,
00181             &NumExtendedFormats,
00182             &NumQueries
00183             );
00184 
00185         if (TRUE == bRet)
00186         {
00187             pDeviceData->DriverCaps.dwDisplayWidth = DriverCaps.dwDisplayWidth;
00188             pDeviceData->DriverCaps.dwDisplayHeight = DriverCaps.dwDisplayHeight;
00189             pDeviceData->DriverCaps.RawDisplayFormat = DriverCaps.RawDisplayFormat;
00190             pDeviceData->DriverCaps.DisplayFormat = DriverCaps.DisplayFormat;
00191             pDeviceData->DriverCaps.dwRefreshRate = DriverCaps.dwRefreshRate;
00192         }
00193 
00194         return bRet;
00195     }
00196 
00197     /* Cleanup of old stuff */
00198     if (pDeviceData->DriverCaps.pSupportedFormatOps)
00199     {
00200         HeapFree(GetProcessHeap(), 0, pDeviceData->DriverCaps.pSupportedFormatOps);
00201         pDeviceData->DriverCaps.pSupportedFormatOps = NULL;
00202     }
00203     if (pDeviceData->DriverCaps.pSupportedExtendedModes)
00204     {
00205         HeapFree(GetProcessHeap(), 0, pDeviceData->DriverCaps.pSupportedExtendedModes);
00206         pDeviceData->DriverCaps.pSupportedExtendedModes = NULL;
00207     }
00208     if (pDeviceData->DriverCaps.pSupportedQueriesList)
00209     {
00210         HeapFree(GetProcessHeap(), 0, pDeviceData->DriverCaps.pSupportedQueriesList);
00211         pDeviceData->DriverCaps.pSupportedQueriesList = NULL;
00212     }
00213 
00214     if (FALSE == CanReenableDirectDrawObject(pDeviceData->pUnknown6BC))
00215     {
00216         DPRINT1("Failed to re-enable DirectDrawObject");
00217         ReleaseInternalDeviceData(pDeviceData);
00218         return FALSE;
00219     }
00220 
00221     bRet = GetD3D9DriverInfo(
00222         pDeviceData->pUnknown6BC,
00223         &pDeviceData->DriverCaps,
00224         &pDeviceData->D3D9Callbacks,
00225         pDeviceData->szDeviceName,
00226         pDeviceData->hD3DRefDll,
00227         &GlobalDriverData,
00228         &D3dExtendedCaps,
00229         NULL,
00230         NULL,
00231         NULL,
00232         NULL,
00233         &NumTextureFormats,
00234         &NumStencilFormats,
00235         &NumExtendedFormats,
00236         &NumQueries
00237         );
00238 
00239     if (FALSE == bRet)
00240     {
00241         DPRINT1("Could not query DirectDrawObject, aborting");
00242         ReleaseInternalDeviceData(pDeviceData);
00243         return FALSE;
00244     }
00245 
00246     puD3dTextureFormats = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, max(NumTextureFormats, 1) * sizeof(DDSURFACEDESC));
00247     pD3dZStencilFormatList = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, max(NumStencilFormats, 1) * sizeof(DDPIXELFORMAT));
00248     pD3dDisplayModeList = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, max(NumExtendedFormats, 1) * sizeof(D3DDISPLAYMODE));
00249     pD3dQueryList = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, max(NumQueries, 1) * sizeof(D3DQUERYTYPE));
00250 
00251     bRet = GetD3D9DriverInfo(
00252         pDeviceData->pUnknown6BC,
00253         &pDeviceData->DriverCaps,
00254         &pDeviceData->D3D9Callbacks,
00255         pDeviceData->szDeviceName,
00256         pDeviceData->hD3DRefDll,
00257         &GlobalDriverData,
00258         &D3dExtendedCaps,
00259         puD3dTextureFormats,
00260         pD3dZStencilFormatList,
00261         pD3dDisplayModeList,
00262         pD3dQueryList,
00263         &NumTextureFormats,
00264         &NumStencilFormats,
00265         &NumExtendedFormats,
00266         &NumQueries
00267         );
00268 
00269     if (FALSE == bRet)
00270     {
00271         DPRINT1("Could not query DirectDrawObject, aborting");
00272         HeapFree(GetProcessHeap(), 0, puD3dTextureFormats);
00273         HeapFree(GetProcessHeap(), 0, pD3dZStencilFormatList);
00274         HeapFree(GetProcessHeap(), 0, pD3dDisplayModeList);
00275         HeapFree(GetProcessHeap(), 0, pD3dQueryList);
00276         ReleaseInternalDeviceData(pDeviceData);
00277         return FALSE;
00278     }
00279 
00280     pDeviceData->DriverCaps.NumSupportedFormatOps = NumTextureFormats;
00281     if (NumTextureFormats > 0)
00282         pDeviceData->DriverCaps.pSupportedFormatOps = puD3dTextureFormats;
00283 
00284     pDeviceData->DriverCaps.NumSupportedExtendedModes = NumExtendedFormats;
00285     if (NumExtendedFormats > 0)
00286         pDeviceData->DriverCaps.pSupportedExtendedModes = pD3dDisplayModeList;
00287 
00288     pDeviceData->DriverCaps.NumSupportedQueries = NumQueries;
00289     if (NumQueries > 0)
00290         pDeviceData->DriverCaps.pSupportedQueriesList = pD3dQueryList;
00291     
00292     HeapFree(GetProcessHeap(), 0, pD3dZStencilFormatList); 
00293 
00294     return TRUE;
00295 }
00296 
00297 
00298 
00299 BOOL CanReenableDirectDrawObject(D3D9_Unknown6BC* pUnknown)
00300 {
00301     BOOL bDisplayModeWasChanged;
00302 
00303     /* Try the real way first */
00304     if (TRUE == OsThunkDdReenableDirectDrawObject(pUnknown->hDirectDrawLocal, &bDisplayModeWasChanged))
00305         return TRUE;
00306 
00307     /* Ref types and software types can always be reenabled after a mode switch */
00308     if (pUnknown->DeviceType == D3DDEVTYPE_REF || pUnknown->DeviceType == D3DDEVTYPE_SW)
00309         return TRUE;
00310 
00311     return FALSE;
00312 }
00313 
00314 
00315 
00316 static void PrepareDriverInfoData(DD_GETDRIVERINFODATA* DrvInfo, LPVOID pData, DWORD dwExpectedSize)
00317 {
00318     memset(DrvInfo, 0, sizeof(DD_GETDRIVERINFODATA));
00319     DrvInfo->dwSize = sizeof(DD_GETDRIVERINFODATA);
00320     DrvInfo->guidInfo = GUID_GetDriverInfo2;
00321     DrvInfo->dwExpectedSize = dwExpectedSize;
00322     DrvInfo->lpvData = pData;
00323     DrvInfo->ddRVal = E_FAIL;
00324 }
00325 
00326 static void ResetGetDriverInfo2Data(DD_GETDRIVERINFO2DATA* DrvInfo2, DWORD dwType, DWORD dwExpectedSize)
00327 {
00328     memset(DrvInfo2, 0, dwExpectedSize);
00329     DrvInfo2->dwMagic = D3DGDI2_MAGIC;
00330     DrvInfo2->dwType = dwType;
00331     DrvInfo2->dwExpectedSize = dwExpectedSize;
00332 }
00333 
00334 BOOL GetD3D9DriverInfo( D3D9_Unknown6BC* pUnknown6BC,
00335                         LPD3D9_DRIVERCAPS pDriverCaps,
00336                         D3D9_CALLBACKS* pD3D9Callbacks,
00337                         LPCSTR lpszDeviceName,
00338                         HMODULE hD3dRefDll,
00339                         D3DHAL_GLOBALDRIVERDATA* pGblDriverData,
00340                         D3DHAL_D3DEXTENDEDCAPS* pD3dExtendedCaps,
00341                         LPDDSURFACEDESC puD3dTextureFormats,
00342                         DDPIXELFORMAT* pD3dZStencilFormatList,
00343                         D3DDISPLAYMODE* pD3dDisplayModeList,
00344                         D3DQUERYTYPE* pD3dQueryList,
00345                         LPDWORD pNumTextureFormats,
00346                         LPDWORD pNumZStencilFormats,
00347                         LPDWORD pNumExtendedFormats,
00348                         LPDWORD pNumQueries)
00349 {
00350     BOOL bRet;
00351     DWORD ValueSize;
00352     DWORD dwDXVersion;
00353 
00354     DD_HALINFO HalInfo;
00355     DWORD CallBackFlags[3];
00356     D3DNTHAL_CALLBACKS D3dCallbacks;
00357     D3DNTHAL_GLOBALDRIVERDATA D3dDriverData;
00358     DD_D3DBUFCALLBACKS D3dBufferCallbacks;
00359     DWORD NumHeaps = 0;
00360     DWORD NumFourCC = 0;
00361 
00362     BOOL bDX8Mode = FALSE;
00363 
00364     DD_GETDRIVERINFODATA DrvInfo;
00365     DD_GETDDIVERSIONDATA DdiVersion;
00366     DD_GETFORMATCOUNTDATA FormatCountData;
00367     DD_GETEXTENDEDMODECOUNTDATA ExModeCountData;
00368     DD_GETD3DQUERYCOUNTDATA D3dQueryCountData;
00369 
00370     /* Init */
00371     *pNumTextureFormats = 0;
00372     *pNumZStencilFormats = 0;
00373     *pNumExtendedFormats = 0;
00374     *pNumQueries = 0;
00375     memset(pD3dExtendedCaps, 0, sizeof(D3DHAL_D3DEXTENDEDCAPS));
00376     memset(pGblDriverData, 0, sizeof(D3DHAL_GLOBALDRIVERDATA));
00377     memset(pDriverCaps, 0, sizeof(D3D9_DRIVERCAPS));
00378 
00379     /* Set runtime version */
00380     ValueSize = sizeof(dwDXVersion);
00381     if (FALSE == ReadRegistryValue(REG_DWORD, "DD_RUNTIME_VERSION", (LPBYTE)&dwDXVersion, &ValueSize))
00382         dwDXVersion = DD_RUNTIME_VERSION;
00383 
00384 
00385     bRet = OsThunkDdQueryDirectDrawObject(
00386         pUnknown6BC->hDirectDrawLocal,
00387         &HalInfo,
00388         CallBackFlags,
00389         &D3dCallbacks,
00390         &D3dDriverData,
00391         &D3dBufferCallbacks,
00392         NULL,
00393         &NumHeaps,
00394         NULL,
00395         &NumFourCC,
00396         NULL
00397         );
00398 
00399     if (bRet == FALSE)
00400     {
00401         /* TODO: Handle error */
00402         return FALSE;
00403     }
00404 
00405     if ((HalInfo.ddCaps.dwSVBCaps2 & DDCAPS2_AUTOFLIPOVERLAY) == 0 &&
00406         puD3dTextureFormats != NULL)
00407     {
00408         bRet = OsThunkDdQueryDirectDrawObject(
00409             pUnknown6BC->hDirectDrawLocal,
00410             &HalInfo,
00411             CallBackFlags,
00412             &D3dCallbacks,
00413             &D3dDriverData,
00414             &D3dBufferCallbacks,
00415             puD3dTextureFormats,
00416             &NumHeaps,
00417             NULL,
00418             &NumFourCC,
00419             NULL
00420             );
00421 
00422         if (FALSE == bRet)
00423             return FALSE;
00424     }
00425 
00426     if (NULL == pUnknown6BC->swDDICreateDirectDrawObject)
00427     {
00428         *pNumTextureFormats = D3dDriverData.dwNumTextureFormats;
00429     }
00430 
00431     pDriverCaps->DriverCaps9.Caps = HalInfo.ddCaps.dwCaps;
00432     pDriverCaps->DriverCaps9.Caps2 = HalInfo.ddCaps.dwCaps2;
00433     pDriverCaps->DriverCaps9.Caps3 = HalInfo.ddCaps.dwSVCaps;
00434     pDriverCaps->dwSVBCaps = HalInfo.ddCaps.dwSVBCaps;
00435     pDriverCaps->dwVSBCaps = HalInfo.ddCaps.dwVSBCaps;
00436     pDriverCaps->dwSVBCaps2 = HalInfo.ddCaps.dwSVBCaps2;
00437     pUnknown6BC->lDisplayPitch = HalInfo.vmiData.lDisplayPitch;
00438 
00439     if (HalInfo.dwFlags & DDHALINFO_GETDRIVERINFO2)
00440     {
00441         /* GUID_GetDriverInfo2 - Inform driver of DX version */
00442         {
00443             DD_DXVERSION DxVersion;
00444 
00445             ResetGetDriverInfo2Data(&DxVersion.gdi2, D3DGDI2_TYPE_DXVERSION, sizeof(DD_DXVERSION));
00446             DxVersion.dwDXVersion = dwDXVersion;
00447 
00448             PrepareDriverInfoData(&DrvInfo, &DxVersion, sizeof(DxVersion));
00449             OsThunkDdGetDriverInfo(pUnknown6BC->hDirectDrawLocal, &DrvInfo);
00450         }
00451 
00452 
00453         /* GUID_GetDriverInfo2 - Get DDI version */
00454         {
00455             ResetGetDriverInfo2Data(&DdiVersion.gdi2, D3DGDI2_TYPE_GETDDIVERSION, sizeof(DD_GETDDIVERSIONDATA));
00456             PrepareDriverInfoData(&DrvInfo, &DdiVersion, sizeof(DdiVersion));
00457             bRet = OsThunkDdGetDriverInfo(pUnknown6BC->hDirectDrawLocal, &DrvInfo);
00458 
00459             if (DdiVersion.dwDDIVersion != DX9_DDI_VERSION)
00460             {
00461                 DWORD ForceDDIOn;
00462 
00463                 ValueSize = sizeof(ForceDDIOn);
00464                 if (TRUE == ReadRegistryValue(REG_DWORD, "ForceOldDDIOn", (LPBYTE)&ForceDDIOn, &ValueSize) &&
00465                     0 != ForceDDIOn)
00466                 {
00467                     DdiVersion.dwDDIVersion = DX9_DDI_VERSION;
00468                 }
00469             }
00470         }
00471 
00472 
00473         /* Check for errors to fallback to DX8 mode  */
00474         if (DdiVersion.dwDDIVersion < DX9_DDI_VERSION)
00475         {
00476             bDX8Mode = TRUE;
00477 
00478             if (DdiVersion.dwDDIVersion == 0)
00479             {
00480                 DPRINT1("Driver claims to be DX9 driver, but didn't report DX9 DDI version - reverting to DX8 mode");
00481             }
00482             else
00483             {
00484                 DPRINT1("Driver claims to be DX9 driver, but was built with an old DDI version - reverting to DX8 mode");
00485             }
00486 
00487             /* GUID_GetDriverInfo2 - Get D3DCAPS8 */
00488             {
00489                 D3DCAPS8 DriverCaps8;
00490 
00491                 ResetGetDriverInfo2Data((DD_GETDRIVERINFO2DATA*)&DriverCaps8, D3DGDI2_TYPE_GETD3DCAPS8, sizeof(D3DCAPS8));
00492                 PrepareDriverInfoData(&DrvInfo, &DriverCaps8, sizeof(D3DCAPS8));
00493                 
00494                 if (FALSE == OsThunkDdGetDriverInfo(pUnknown6BC->hDirectDrawLocal, &DrvInfo) ||
00495                     S_OK != DrvInfo.ddRVal ||
00496                     DrvInfo.dwActualSize != sizeof(D3DCAPS8))
00497                 {
00498                     DPRINT1("Driver returned an invalid D3DCAPS8 structure - aborting");
00499                     return FALSE;
00500                 }
00501 
00502                 memcpy(&pDriverCaps->DriverCaps9, &DriverCaps8, sizeof(D3DCAPS8));
00503                 pDriverCaps->DriverCaps9.Caps = HalInfo.ddCaps.dwCaps;
00504                 pDriverCaps->dwDriverCaps |= D3D9_INT_D3DCAPS8_VALID;
00505             }
00506         }
00507 
00508 
00509         /* GUID_GetDriverInfo2 - Get D3DCAPS9 */
00510         if (FALSE == bDX8Mode)
00511         {
00512             D3DCAPS9 DriverCaps9;
00513 
00514             ResetGetDriverInfo2Data((DD_GETDRIVERINFO2DATA*)&DriverCaps9, D3DGDI2_TYPE_GETD3DCAPS9, sizeof(D3DCAPS9));
00515             PrepareDriverInfoData(&DrvInfo, &DriverCaps9, sizeof(D3DCAPS9));
00516             
00517             if (FALSE == OsThunkDdGetDriverInfo(pUnknown6BC->hDirectDrawLocal, &DrvInfo) ||
00518                 S_OK != DrvInfo.ddRVal ||
00519                 DrvInfo.dwActualSize != sizeof(D3DCAPS9))
00520             {
00521                 DPRINT1("Driver returned an invalid D3DCAPS9 structure - aborting");
00522                 return FALSE;
00523             }
00524 
00525             pDriverCaps->DriverCaps9 = DriverCaps9;
00526             pDriverCaps->DriverCaps9.Caps = HalInfo.ddCaps.dwCaps;
00527             pDriverCaps->dwDriverCaps |= D3D9_INT_D3DCAPS9_VALID;
00528         }
00529 
00530 
00531         /* GUID_GetDriverInfo2 - Get format count data */
00532         {
00533             ResetGetDriverInfo2Data(&FormatCountData.gdi2, D3DGDI2_TYPE_GETFORMATCOUNT, sizeof(DD_GETFORMATCOUNTDATA));
00534             PrepareDriverInfoData(&DrvInfo, &FormatCountData, sizeof(DD_GETFORMATCOUNTDATA));
00535             FormatCountData.dwFormatCount = UINT_MAX;
00536             FormatCountData.dwReserved = dwDXVersion;
00537 
00538             if (TRUE == OsThunkDdGetDriverInfo(pUnknown6BC->hDirectDrawLocal, &DrvInfo))
00539             {
00540                 if (DrvInfo.ddRVal != S_OK)
00541                 {
00542                     DPRINT1("Driver claimed to be DX9 driver, but didn't support D3DGDI_TYPE_GETFORMATCOUNT in GetDriverInfo call");
00543                     return FALSE;
00544                 }
00545                 else if (DrvInfo.dwActualSize != sizeof(DD_GETFORMATCOUNTDATA))
00546                 {
00547                     DPRINT1("Driver returned an invalid DD_GETFORMATCOUNTDATA structure - aborting");
00548                     return FALSE;
00549                 }
00550                 else if (FormatCountData.dwFormatCount == UINT_MAX)
00551                 {
00552                     DPRINT1("Driver didn't set DD_GETFORMATCOUNTDATA.dwFormatCount - aborting");
00553                     return FALSE;
00554                 }
00555 
00556                 *pNumTextureFormats = FormatCountData.dwFormatCount;
00557             }
00558         }
00559 
00560         /* GUID_GetDriverInfo2 - Get format data */
00561         if (puD3dTextureFormats != NULL)
00562         {
00563             DWORD FormatIndex;
00564             DD_GETFORMATDATA FormatData;
00565 
00566             for (FormatIndex = 0; FormatIndex < FormatCountData.dwFormatCount; FormatIndex++)
00567             {
00568                 ResetGetDriverInfo2Data(&FormatData.gdi2, D3DGDI2_TYPE_GETFORMAT, sizeof(DD_GETFORMATDATA));
00569                 PrepareDriverInfoData(&DrvInfo, &FormatData, sizeof(DD_GETFORMATDATA));
00570                 FormatData.dwFormatIndex = FormatIndex;
00571 
00572                 if (TRUE == OsThunkDdGetDriverInfo(pUnknown6BC->hDirectDrawLocal, &DrvInfo))
00573                 {
00574                     if (DrvInfo.ddRVal != S_OK)
00575                     {
00576                         DPRINT1("Driver claimed to be DX9 driver, but didn't support D3DGDI_TYPE_GETFORMAT in GetDriverInfo call");
00577                         return FALSE;
00578                     }
00579                     else if (DrvInfo.dwActualSize != sizeof(DD_GETFORMATDATA))
00580                     {
00581                         DPRINT1("Driver returned an invalid DD_GETFORMATDATA structure - aborting");
00582                         return FALSE;
00583                     }
00584                     else if (FormatData.format.dwSize != sizeof(DDPIXELFORMAT))
00585                     {
00586                         DPRINT1("Driver didn't set DD_GETFORMATDATA.format - aborting");
00587                         return FALSE;
00588                     }
00589 
00590                     /* Copy format data to puD3dTextureFormats */
00591                     memset(puD3dTextureFormats, 0, sizeof(DDSURFACEDESC));
00592                     puD3dTextureFormats->dwSize = sizeof(DDSURFACEDESC);
00593                     puD3dTextureFormats->dwFlags = DDSD_PIXELFORMAT;
00594                     memcpy(&puD3dTextureFormats->ddpfPixelFormat, &FormatData.format, sizeof(DDPIXELFORMAT));
00595 
00596                     if ((FormatData.format.dwOperations & D3DFORMAT_OP_PIXELSIZE) != 0 &&
00597                         FormatData.format.dwPrivateFormatBitCount > 0)
00598                     {
00599                         /* TODO: Register driver's own pixelformat */
00600                     }
00601 
00602                     ++puD3dTextureFormats;
00603                 }
00604             }
00605         }
00606 
00607         /* GUID_GetDriverInfo2 - Get extended mode count data */
00608         {
00609             ResetGetDriverInfo2Data(&ExModeCountData.gdi2, D3DGDI2_TYPE_GETEXTENDEDMODECOUNT, sizeof(DD_GETEXTENDEDMODECOUNTDATA));
00610             PrepareDriverInfoData(&DrvInfo, &ExModeCountData, sizeof(DD_GETEXTENDEDMODECOUNTDATA));
00611             ExModeCountData.dwModeCount = UINT_MAX;
00612             ExModeCountData.dwReserved = dwDXVersion;
00613 
00614             if (TRUE == OsThunkDdGetDriverInfo(pUnknown6BC->hDirectDrawLocal, &DrvInfo))
00615             {
00616                 if (DrvInfo.ddRVal == S_OK)
00617                 {
00618                     if (DrvInfo.dwActualSize != sizeof(DD_GETEXTENDEDMODECOUNTDATA))
00619                     {
00620                         DPRINT1("Driver returned an invalid DD_GETEXTENDEDFORMATCOUNTDATA structure - aborting");
00621                         return FALSE;
00622                     }
00623                     else if (ExModeCountData.dwModeCount == UINT_MAX)
00624                     {
00625                         DPRINT1("Driver didn't set DD_GETEXTENDEDMODECOUNTDATA.dwModeCount - aborting");
00626                         return FALSE;
00627                     }
00628 
00629                     *pNumExtendedFormats = ExModeCountData.dwModeCount;
00630                 }
00631                 else
00632                 {
00633                     ExModeCountData.dwModeCount = 0;
00634                 }
00635             }
00636         }
00637 
00638         /* GUID_GetDriverInfo2 - Get extended mode data */
00639         if (pD3dDisplayModeList != NULL)
00640         {
00641             DWORD ModeIndex;
00642             DD_GETEXTENDEDMODEDATA ExModeData;
00643 
00644             for (ModeIndex = 0; ModeIndex < ExModeCountData.dwModeCount; ModeIndex++)
00645             {
00646                 ResetGetDriverInfo2Data(&ExModeData.gdi2, D3DGDI2_TYPE_GETEXTENDEDMODE, sizeof(DD_GETEXTENDEDMODEDATA));
00647                 PrepareDriverInfoData(&DrvInfo, &ExModeData, sizeof(DD_GETEXTENDEDMODEDATA));
00648                 ExModeData.dwModeIndex = ModeIndex;
00649                 ExModeData.mode.Width = UINT_MAX;
00650 
00651                 if (TRUE == OsThunkDdGetDriverInfo(pUnknown6BC->hDirectDrawLocal, &DrvInfo))
00652                 {
00653                     if (DrvInfo.ddRVal != S_OK)
00654                     {
00655                         DPRINT1("Driver claimed to be DX9 driver, but didn't support D3DGDI2_TYPE_GETEXTENDEDMODE in GetDriverInfo call");
00656                         return FALSE;
00657                     }
00658                     else if (DrvInfo.dwActualSize != sizeof(DD_GETEXTENDEDMODEDATA))
00659                     {
00660                         DPRINT1("Driver returned an invalid DD_GETEXTENDEDMODEDATA structure - aborting");
00661                         return FALSE;
00662                     }
00663                     else if (ExModeData.mode.Width != UINT_MAX)
00664                     {
00665                         DPRINT1("Driver didn't set DD_GETEXTENDEDMODEDATA.mode - aborting");
00666                         return FALSE;
00667                     }
00668 
00669                     memcpy(pD3dDisplayModeList, &ExModeData.mode, sizeof(D3DDISPLAYMODE));
00670                     ++pD3dDisplayModeList;
00671                 }
00672             }
00673         }
00674 
00675         /* GUID_GetDriverInfo2 - Get adapter group */
00676         {
00677             DD_GETADAPTERGROUPDATA AdapterGroupData;
00678             ResetGetDriverInfo2Data(&AdapterGroupData.gdi2, D3DGDI2_TYPE_GETADAPTERGROUP, sizeof(DD_GETADAPTERGROUPDATA));
00679             PrepareDriverInfoData(&DrvInfo, &AdapterGroupData, sizeof(DD_GETADAPTERGROUPDATA));
00680             AdapterGroupData.ulUniqueAdapterGroupId = UINT_MAX;
00681 
00682             if (TRUE == OsThunkDdGetDriverInfo(pUnknown6BC->hDirectDrawLocal, &DrvInfo))
00683             {
00684                 if (DrvInfo.ddRVal != S_OK)
00685                 {
00686                     DPRINT1("Driver claimed to be DX9 driver, but didn't support D3DGDI2_TYPE_GETADAPTERGROUP in GetDriverInfo call");
00687                     return FALSE;
00688                 }
00689                 else if (DrvInfo.dwActualSize != sizeof(DD_GETADAPTERGROUPDATA))
00690                 {
00691                     DPRINT1("Driver returned an invalid DD_GETADAPTERGROUPDATA structure - aborting");
00692                     return FALSE;
00693                 }
00694                 else if (AdapterGroupData.ulUniqueAdapterGroupId == UINT_MAX)
00695                 {
00696                     DPRINT1("Driver didn't set DD_GETADAPTERGROUPDATA.ulUniqueAdapterGroupId - aborting");
00697                     return FALSE;
00698                 }
00699 
00700                 pDriverCaps->ulUniqueAdapterGroupId = (ULONG)AdapterGroupData.ulUniqueAdapterGroupId;
00701             }
00702         }
00703 
00704         /* GUID_GetDriverInfo2 - Query count data */
00705         {
00706             ResetGetDriverInfo2Data(&D3dQueryCountData.gdi2, D3DGDI2_TYPE_GETD3DQUERYCOUNT, sizeof(DD_GETD3DQUERYCOUNTDATA));
00707             PrepareDriverInfoData(&DrvInfo, &D3dQueryCountData, sizeof(DD_GETD3DQUERYCOUNTDATA));
00708             D3dQueryCountData.dwNumQueries = UINT_MAX;
00709 
00710             if (TRUE == OsThunkDdGetDriverInfo(pUnknown6BC->hDirectDrawLocal, &DrvInfo))
00711             {
00712                 if (DrvInfo.ddRVal != S_OK)
00713                 {
00714                     DPRINT1("Driver claimed to be DX9 driver, but didn't support D3DGDI2_TYPE_GETD3DQUERYCOUNT in GetDriverInfo call");
00715                     return FALSE;
00716                 }
00717                 else if (DrvInfo.dwActualSize != sizeof(DD_GETD3DQUERYCOUNTDATA))
00718                 {
00719                     DPRINT1("Driver returned an invalid DD_GETD3DQUERYCOUNTDATA structure - aborting");
00720                     return FALSE;
00721                 }
00722                 else if (D3dQueryCountData.dwNumQueries == UINT_MAX)
00723                 {
00724                     DPRINT1("Driver didn't set DD_GETD3DQUERYCOUNTDATA.dwNumQueries - aborting");
00725                     return FALSE;
00726                 }
00727 
00728                 *pNumQueries = D3dQueryCountData.dwNumQueries;
00729             }
00730         }
00731 
00732         /* GUID_GetDriverInfo2 - Query data */
00733         if (pD3dQueryList != NULL)
00734         {
00735             DWORD QueryIndex;
00736             DD_GETD3DQUERYDATA D3dQueryData;
00737 
00738             for (QueryIndex = 0; QueryIndex < D3dQueryCountData.dwNumQueries; QueryIndex++)
00739             {
00740                 ResetGetDriverInfo2Data(&D3dQueryData.gdi2, D3DGDI2_TYPE_GETD3DQUERY, sizeof(DD_GETD3DQUERYDATA));
00741                 PrepareDriverInfoData(&DrvInfo, &D3dQueryData, sizeof(DD_GETD3DQUERYDATA));
00742                 D3dQueryData.dwQueryIndex = QueryIndex;
00743 
00744                 if (TRUE == OsThunkDdGetDriverInfo(pUnknown6BC->hDirectDrawLocal, &DrvInfo))
00745                 {
00746                     if (DrvInfo.ddRVal != S_OK)
00747                     {
00748                         DPRINT1("Driver claimed to be DX9 driver, but didn't support D3DGDI2_TYPE_GETD3DQUERY in GetDriverInfo call");
00749                         return FALSE;
00750                     }
00751                     else if (DrvInfo.dwActualSize != sizeof(DD_GETD3DQUERYDATA))
00752                     {
00753                         DPRINT1("Driver returned an invalid DD_GETD3DQUERYDATA structure - aborting");
00754                         return FALSE;
00755                     }
00756 
00757                     *pD3dQueryList = D3dQueryData.QueryType;
00758                     ++pD3dQueryList;
00759                 }
00760             }
00761         }
00762     }
00763 
00764     /* D3dDriverData -> pGblDriverData */
00765     memcpy(&pGblDriverData->hwCaps, &D3dDriverData.hwCaps, sizeof(D3DNTHALDEVICEDESC_V1));
00766     pGblDriverData->dwNumVertices = D3dDriverData.dwNumVertices;
00767     pGblDriverData->dwNumClipVertices = D3dDriverData.dwNumClipVertices;
00768 
00769     /* GUID_D3DExtendedCaps */
00770     {     
00771         DrvInfo.dwSize = sizeof(DD_GETDRIVERINFODATA);
00772         DrvInfo.guidInfo = GUID_D3DExtendedCaps;
00773         DrvInfo.dwExpectedSize = sizeof(D3DHAL_D3DEXTENDEDCAPS);
00774         DrvInfo.lpvData = pD3dExtendedCaps;
00775         bRet = OsThunkDdGetDriverInfo(pUnknown6BC->hDirectDrawLocal, &DrvInfo);
00776 
00777         if (TRUE != bRet || DrvInfo.ddRVal != S_OK)
00778         {
00779             DPRINT1("Driver failed call to GetDriverInfo() with: GUID_D3DExtendedCaps");
00780             return FALSE;
00781         }
00782     }
00783 
00784     /* GUID_ZPixelFormats */
00785     {
00786         DDPIXELFORMAT *pZPixelFormats = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, FormatCountData.dwFormatCount * sizeof(DDPIXELFORMAT));
00787 
00788         DrvInfo.dwSize = sizeof(DD_GETDRIVERINFODATA);
00789         DrvInfo.guidInfo = GUID_ZPixelFormats;
00790         DrvInfo.dwExpectedSize = FormatCountData.dwFormatCount * sizeof(DDPIXELFORMAT);
00791         DrvInfo.lpvData = pZPixelFormats;
00792         bRet = OsThunkDdGetDriverInfo(pUnknown6BC->hDirectDrawLocal, &DrvInfo);
00793 
00794         if (TRUE != bRet || DrvInfo.ddRVal != S_OK)
00795         {
00796             DPRINT1("Driver failed call to GetDriverInfo() with: GUID_ZPixelFormats");
00797             HeapFree(GetProcessHeap(), 0, pZPixelFormats);
00798             return FALSE;
00799         }
00800 
00801         *pNumZStencilFormats = FormatCountData.dwFormatCount;
00802 
00803         if (pD3dZStencilFormatList != NULL)
00804             memcpy(pD3dZStencilFormatList, pZPixelFormats, FormatCountData.dwFormatCount * sizeof(DDPIXELFORMAT));
00805 
00806         HeapFree(GetProcessHeap(), 0, pZPixelFormats);
00807     }
00808 
00809     /* Get current display format */
00810     {
00811         D3DDISPLAYMODE CurrentDisplayMode;
00812         GetAdapterMode(lpszDeviceName, &CurrentDisplayMode);
00813         pUnknown6BC->RawDisplayFormat = CurrentDisplayMode.Format;
00814         pUnknown6BC->DisplayFormat = CurrentDisplayMode.Format;
00815 
00816         if ((HalInfo.vmiData.ddpfDisplay.dwFlags & DDPF_ALPHAPIXELS) != 0)
00817         {
00818             if (CurrentDisplayMode.Format == D3DFMT_X8R8G8B8)
00819             {
00820                 pUnknown6BC->DisplayFormat = D3DFMT_A8R8G8B8;
00821             }
00822             else if (CurrentDisplayMode.Format == D3DFMT_X1R5G5B5)
00823             {
00824                 pUnknown6BC->DisplayFormat = D3DFMT_A1R5G5B5;
00825             }
00826         }
00827 
00828         pDriverCaps->dwDisplayWidth = CurrentDisplayMode.Width;
00829         pDriverCaps->dwDisplayHeight = CurrentDisplayMode.Height;
00830         pDriverCaps->RawDisplayFormat = CurrentDisplayMode.Format;
00831         pDriverCaps->DisplayFormat = pUnknown6BC->DisplayFormat;
00832         pDriverCaps->dwRefreshRate = CurrentDisplayMode.RefreshRate;
00833     }
00834 
00835     /* TODO: Set all internal function pointers to create surface, etc. */
00836     pD3D9Callbacks->DdGetAvailDriverMemory = &D3d9GetAvailDriverMemory;
00837 
00838     /* Set device rect */
00839     {
00840         HMONITOR hMonitor;
00841         MONITORINFO MonitorInfo;
00842         
00843         memset(&MonitorInfo, 0, sizeof(MONITORINFO));
00844         MonitorInfo.cbSize = sizeof(MONITORINFO);
00845         
00846         hMonitor = GetAdapterMonitor(lpszDeviceName);
00847         if (TRUE == GetMonitorInfoA(hMonitor, &MonitorInfo))
00848         {
00849             pUnknown6BC->DeviceRect = MonitorInfo.rcMonitor;
00850         }
00851         else
00852         {
00853             DPRINT1("Could not get monitor information");
00854         }
00855     }
00856 
00857     pUnknown6BC->dwCaps = pDriverCaps->DriverCaps9.Caps;
00858     pUnknown6BC->dwSVBCaps = pDriverCaps->dwSVBCaps;
00859 
00860     if (FALSE == bDX8Mode)
00861     {
00862         pUnknown6BC->MajorDxVersion = 9;
00863 
00864         if (0 != (pDriverCaps->DriverCaps9.VertexProcessingCaps & D3DVTXPCAPS_NO_VSDT_UBYTE4))
00865         {
00866             DPRINT1("Driver claimed to be DX9 driver, but used depricated D3DCAPS9.VertexProcessingCaps: D3DVTXPCAPS_NO_VSDT_UBYTE4 instead of not setting D3DCAPS9.DeclTypes: D3DDTCAPS_UBYTE4.");
00867             return FALSE;
00868         }
00869     }
00870     else
00871     {
00872         pUnknown6BC->MajorDxVersion = 8;
00873 
00874         if (0 == (pDriverCaps->DriverCaps9.VertexProcessingCaps & D3DVTXPCAPS_NO_VSDT_UBYTE4))
00875         {
00876             pDriverCaps->DriverCaps9.DeclTypes |= D3DDTCAPS_UBYTE4;
00877             pDriverCaps->DriverCaps9.VertexProcessingCaps &= ~D3DVTXPCAPS_NO_VSDT_UBYTE4;
00878         }
00879     }
00880 
00881     return TRUE;
00882 }
Generated on Sun May 27 2012 04:21:13 for ReactOS by
1.7.6.1