647 lines
18 KiB
C++
647 lines
18 KiB
C++
#include "StdAfx.h"
|
|
#include "../eterBase/Stl.h"
|
|
#include "GrpDetector.h"
|
|
|
|
struct FIsEqualD3DDisplayMode
|
|
{
|
|
FIsEqualD3DDisplayMode(D3DDISPLAYMODE* pkD3DDMChk)
|
|
{
|
|
m_pkD3DDMChk=pkD3DDMChk;
|
|
}
|
|
BOOL operator() (D3DDISPLAYMODE& rkD3DDMTest)
|
|
{
|
|
if (rkD3DDMTest.Width!=m_pkD3DDMChk->Width)
|
|
return FALSE;
|
|
|
|
if (rkD3DDMTest.Height!=m_pkD3DDMChk->Height)
|
|
return FALSE;
|
|
|
|
if (rkD3DDMTest.Format!=m_pkD3DDMChk->Format)
|
|
return FALSE;
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
D3DDISPLAYMODE* m_pkD3DDMChk;
|
|
};
|
|
|
|
static int CompareD3DDisplayModeOrder( const VOID* arg1, const VOID* arg2 )
|
|
{
|
|
D3DDISPLAYMODE* p1 = (D3DDISPLAYMODE*)arg1;
|
|
D3DDISPLAYMODE* p2 = (D3DDISPLAYMODE*)arg2;
|
|
|
|
if( p1->Format > p2->Format ) return -1;
|
|
if( p1->Format < p2->Format ) return +1;
|
|
if( p1->Width < p2->Width ) return -1;
|
|
if( p1->Width > p2->Width ) return +1;
|
|
if( p1->Height < p2->Height ) return -1;
|
|
if( p1->Height > p2->Height ) return +1;
|
|
|
|
return 0;
|
|
}
|
|
|
|
|
|
|
|
/////////////////////////////////////////////////////////////////////////////////
|
|
|
|
UINT D3D_CAdapterDisplayModeList::GetDisplayModeNum()
|
|
{
|
|
return m_uD3DDMNum;
|
|
}
|
|
|
|
UINT D3D_CAdapterDisplayModeList::GetPixelFormatNum()
|
|
{
|
|
return m_uD3DFmtNum;
|
|
}
|
|
|
|
|
|
const D3DDISPLAYMODE& D3D_CAdapterDisplayModeList::GetDisplayModer(UINT iD3DDM)
|
|
{
|
|
assert(iD3DDM<m_uD3DDMNum);
|
|
return m_akD3DDM[iD3DDM];
|
|
}
|
|
|
|
const D3DFORMAT& D3D_CAdapterDisplayModeList::GetPixelFormatr(UINT iD3DFmt)
|
|
{
|
|
assert(iD3DFmt<m_uD3DFmtNum);
|
|
return m_aeD3DFmt[iD3DFmt];
|
|
}
|
|
|
|
VOID D3D_CAdapterDisplayModeList::Build(IDirect3D8& rkD3D, D3DFORMAT eD3DFmtDefault, UINT iD3DAdapterInfo)
|
|
{
|
|
D3DDISPLAYMODE* akD3DDM=m_akD3DDM;
|
|
D3DFORMAT* aeD3DFmt=m_aeD3DFmt;
|
|
|
|
UINT uD3DDMNum=0;
|
|
UINT uD3DFmtNum=0;
|
|
|
|
aeD3DFmt[uD3DFmtNum++]=eD3DFmtDefault;
|
|
|
|
UINT uAdapterModeNum=rkD3D.GetAdapterModeCount(iD3DAdapterInfo);
|
|
for (UINT iD3DAdapterInfoMode=0; iD3DAdapterInfoMode<uAdapterModeNum; iD3DAdapterInfoMode++)
|
|
{
|
|
D3DDISPLAYMODE kD3DDMCur;
|
|
rkD3D.EnumAdapterModes(iD3DAdapterInfo, iD3DAdapterInfoMode, &kD3DDMCur);
|
|
|
|
// IsFilterOutLowResolutionMode
|
|
if( kD3DDMCur.Width < FILTEROUT_LOWRESOLUTION_WIDTH || kD3DDMCur.Height < FILTEROUT_LOWRESOLUTION_HEIGHT )
|
|
continue;
|
|
|
|
// FindDisplayMode
|
|
D3DDISPLAYMODE* pkD3DDMEnd=akD3DDM+uD3DDMNum;
|
|
D3DDISPLAYMODE* pkD3DDMFind=std::find_if(akD3DDM, pkD3DDMEnd, FIsEqualD3DDisplayMode(&kD3DDMCur));
|
|
|
|
// IsNewDisplayMode
|
|
if (pkD3DDMFind==pkD3DDMEnd && uD3DDMNum<D3DDISPLAYMODE_MAX)
|
|
{
|
|
D3DDISPLAYMODE& rkD3DDMNew=akD3DDM[uD3DDMNum++];
|
|
rkD3DDMNew.Width=kD3DDMCur.Width;
|
|
rkD3DDMNew.Height=kD3DDMCur.Height;
|
|
rkD3DDMNew.Format=kD3DDMCur.Format;
|
|
|
|
// FindFormat
|
|
D3DFORMAT* peD3DFmtEnd=aeD3DFmt+uD3DFmtNum;
|
|
D3DFORMAT* peD3DFmtFind=std::find(aeD3DFmt, peD3DFmtEnd, kD3DDMCur.Format);
|
|
|
|
// IsNewFormat
|
|
if (peD3DFmtFind==peD3DFmtEnd && uD3DFmtNum<D3DFORMAT_MAX)
|
|
{
|
|
aeD3DFmt[uD3DFmtNum++]=kD3DDMCur.Format;
|
|
}
|
|
}
|
|
}
|
|
|
|
qsort(akD3DDM, uD3DDMNum, sizeof(D3DDISPLAYMODE), CompareD3DDisplayModeOrder);
|
|
|
|
m_uD3DFmtNum=uD3DFmtNum;
|
|
m_uD3DDMNum=uD3DDMNum;
|
|
}
|
|
|
|
/////////////////////////////////////////////////////////////////////////////////
|
|
|
|
VOID D3D_SModeInfo::GetString(std::string* pstEnumList)
|
|
{
|
|
UINT uScrDepthBits=16;
|
|
switch (m_eD3DFmtPixel)
|
|
{
|
|
case D3DFMT_X8R8G8B8:
|
|
case D3DFMT_A8R8G8B8:
|
|
case D3DFMT_R8G8B8:
|
|
uScrDepthBits=32;
|
|
break;
|
|
}
|
|
|
|
int iVP=0;
|
|
|
|
switch (m_dwD3DBehavior)
|
|
{
|
|
case D3DCREATE_HARDWARE_VERTEXPROCESSING:
|
|
iVP=1;
|
|
break;
|
|
case D3DCREATE_MIXED_VERTEXPROCESSING:
|
|
iVP=2;
|
|
break;
|
|
case D3DCREATE_SOFTWARE_VERTEXPROCESSING:
|
|
iVP=3;
|
|
break;
|
|
}
|
|
|
|
static const char* szVP[4]=
|
|
{
|
|
"UNKNOWN",
|
|
"HWVP",
|
|
"MXVP",
|
|
"SWVP",
|
|
};
|
|
|
|
char szText[1024+1];
|
|
_snprintf(szText, sizeof(szText), "%dx%dx%d %s\r\n", m_uScrWidth, m_uScrHeight, uScrDepthBits, szVP[iVP]);
|
|
pstEnumList->append(szText);
|
|
}
|
|
|
|
/////////////////////////////////////////////////////////////////////////////////
|
|
|
|
const CHAR* D3D_CDeviceInfo::msc_aszD3DDevDesc[D3DDEVICETYPE_NUM] = {"HAL", "REF"};
|
|
const D3DDEVTYPE D3D_CDeviceInfo::msc_aeD3DDevType[D3DDEVICETYPE_NUM]={D3DDEVTYPE_HAL, D3DDEVTYPE_REF};
|
|
|
|
|
|
UINT D3D_CDeviceInfo::GetD3DModeInfoNum()
|
|
{
|
|
return m_uD3DModeInfoNum;
|
|
}
|
|
|
|
D3D_SModeInfo* D3D_CDeviceInfo::GetD3DModeInfop(UINT iD3D_SModeInfo)
|
|
{
|
|
if (iD3D_SModeInfo >= m_uD3DModeInfoNum)
|
|
return NULL;
|
|
|
|
return &m_akD3DModeInfo[iD3D_SModeInfo];
|
|
}
|
|
|
|
BOOL D3D_CDeviceInfo::FindDepthStencilFormat(IDirect3D8& rkD3D, UINT iD3DAdapterInfo, D3DDEVTYPE DeviceType, D3DFORMAT TargetFormat, D3DFORMAT* pDepthStencilFormat )
|
|
{
|
|
UINT m_dwMinDepthBits = 16;
|
|
UINT m_dwMinStencilBits = 0;
|
|
|
|
if( m_dwMinDepthBits <= 16 && m_dwMinStencilBits == 0 )
|
|
{
|
|
if( SUCCEEDED( rkD3D.CheckDeviceFormat( iD3DAdapterInfo, DeviceType,
|
|
TargetFormat, D3DUSAGE_DEPTHSTENCIL, D3DRTYPE_SURFACE, D3DFMT_D16 ) ) )
|
|
{
|
|
if( SUCCEEDED( rkD3D.CheckDepthStencilMatch( iD3DAdapterInfo, DeviceType,
|
|
TargetFormat, TargetFormat, D3DFMT_D16 ) ) )
|
|
{
|
|
*pDepthStencilFormat = D3DFMT_D16;
|
|
return TRUE;
|
|
}
|
|
}
|
|
}
|
|
|
|
if( m_dwMinDepthBits <= 15 && m_dwMinStencilBits <= 1 )
|
|
{
|
|
if( SUCCEEDED( rkD3D.CheckDeviceFormat( iD3DAdapterInfo, DeviceType,
|
|
TargetFormat, D3DUSAGE_DEPTHSTENCIL, D3DRTYPE_SURFACE, D3DFMT_D15S1 ) ) )
|
|
{
|
|
if( SUCCEEDED( rkD3D.CheckDepthStencilMatch( iD3DAdapterInfo, DeviceType,
|
|
TargetFormat, TargetFormat, D3DFMT_D15S1 ) ) )
|
|
{
|
|
*pDepthStencilFormat = D3DFMT_D15S1;
|
|
return TRUE;
|
|
}
|
|
}
|
|
}
|
|
|
|
if( m_dwMinDepthBits <= 24 && m_dwMinStencilBits == 0 )
|
|
{
|
|
if( SUCCEEDED( rkD3D.CheckDeviceFormat( iD3DAdapterInfo, DeviceType,
|
|
TargetFormat, D3DUSAGE_DEPTHSTENCIL, D3DRTYPE_SURFACE, D3DFMT_D24X8 ) ) )
|
|
{
|
|
if( SUCCEEDED( rkD3D.CheckDepthStencilMatch( iD3DAdapterInfo, DeviceType,
|
|
TargetFormat, TargetFormat, D3DFMT_D24X8 ) ) )
|
|
{
|
|
*pDepthStencilFormat = D3DFMT_D24X8;
|
|
return TRUE;
|
|
}
|
|
}
|
|
}
|
|
|
|
if( m_dwMinDepthBits <= 24 && m_dwMinStencilBits <= 8 )
|
|
{
|
|
if( SUCCEEDED( rkD3D.CheckDeviceFormat( iD3DAdapterInfo, DeviceType,
|
|
TargetFormat, D3DUSAGE_DEPTHSTENCIL, D3DRTYPE_SURFACE, D3DFMT_D24S8 ) ) )
|
|
{
|
|
if( SUCCEEDED( rkD3D.CheckDepthStencilMatch( iD3DAdapterInfo, DeviceType,
|
|
TargetFormat, TargetFormat, D3DFMT_D24S8 ) ) )
|
|
{
|
|
*pDepthStencilFormat = D3DFMT_D24S8;
|
|
return TRUE;
|
|
}
|
|
}
|
|
}
|
|
|
|
if( m_dwMinDepthBits <= 24 && m_dwMinStencilBits <= 4 )
|
|
{
|
|
if( SUCCEEDED( rkD3D.CheckDeviceFormat( iD3DAdapterInfo, DeviceType,
|
|
TargetFormat, D3DUSAGE_DEPTHSTENCIL, D3DRTYPE_SURFACE, D3DFMT_D24X4S4 ) ) )
|
|
{
|
|
if( SUCCEEDED( rkD3D.CheckDepthStencilMatch( iD3DAdapterInfo, DeviceType,
|
|
TargetFormat, TargetFormat, D3DFMT_D24X4S4 ) ) )
|
|
{
|
|
*pDepthStencilFormat = D3DFMT_D24X4S4;
|
|
return TRUE;
|
|
}
|
|
}
|
|
}
|
|
|
|
if( m_dwMinDepthBits <= 32 && m_dwMinStencilBits == 0 )
|
|
{
|
|
if( SUCCEEDED( rkD3D.CheckDeviceFormat( iD3DAdapterInfo, DeviceType,
|
|
TargetFormat, D3DUSAGE_DEPTHSTENCIL, D3DRTYPE_SURFACE, D3DFMT_D32 ) ) )
|
|
{
|
|
if( SUCCEEDED( rkD3D.CheckDepthStencilMatch( iD3DAdapterInfo, DeviceType,
|
|
TargetFormat, TargetFormat, D3DFMT_D32 ) ) )
|
|
{
|
|
*pDepthStencilFormat = D3DFMT_D32;
|
|
return TRUE;
|
|
}
|
|
}
|
|
}
|
|
|
|
return FALSE;
|
|
}
|
|
|
|
BOOL D3D_CDeviceInfo::Build(IDirect3D8& rkD3D, UINT iD3DAdapterInfo, UINT iDevType, D3D_CAdapterDisplayModeList& rkD3DADMList, BOOL (*pfnConfirmDevice)(D3DCAPS8& rkD3DCaps, UINT uBehavior, D3DFORMAT eD3DFmt))
|
|
{
|
|
assert(pfnConfirmDevice!=NULL && "D3D_CDeviceInfo::Build");
|
|
|
|
const D3DDEVTYPE c_eD3DDevType=msc_aeD3DDevType[iDevType];
|
|
const TCHAR* c_szD3DDevDesc=msc_aszD3DDevDesc[iDevType];
|
|
|
|
m_eD3DDevType = c_eD3DDevType;
|
|
rkD3D.GetDeviceCaps(iD3DAdapterInfo, c_eD3DDevType, &m_kD3DCaps);
|
|
|
|
m_szDevDesc = c_szD3DDevDesc;
|
|
m_uD3DModeInfoNum=0;
|
|
m_canDoWindowed = FALSE;
|
|
m_isWindowed = FALSE;
|
|
m_eD3DMSTFullscreen = D3DMULTISAMPLE_NONE;
|
|
m_eD3DMSTWindowed = D3DMULTISAMPLE_NONE;
|
|
|
|
BOOL aisFormatConfirmed[20];
|
|
DWORD adwD3DBehavior[20];
|
|
D3DFORMAT aeD3DFmtDepthStencil[20];
|
|
|
|
BOOL isHALExists = FALSE;
|
|
BOOL isHALWindowedCompatible = FALSE;
|
|
BOOL isHALDesktopCompatible = FALSE;
|
|
BOOL isHALSampleCompatible = FALSE;
|
|
|
|
// GetFlagInfo
|
|
{
|
|
UINT uD3DFmtNum=rkD3DADMList.GetPixelFormatNum();
|
|
|
|
for (DWORD iFmt=0; iFmt<uD3DFmtNum; ++iFmt)
|
|
{
|
|
D3DFORMAT eD3DFmtPixel=rkD3DADMList.GetPixelFormatr(iFmt);
|
|
DWORD dwD3DBehavior=0;
|
|
BOOL isFormatConfirmed=FALSE;
|
|
|
|
aeD3DFmtDepthStencil[iFmt] = D3DFMT_UNKNOWN;
|
|
|
|
// SkipNoRenderTargetFormat;
|
|
if (FAILED(rkD3D.CheckDeviceType(iD3DAdapterInfo, m_eD3DDevType, eD3DFmtPixel, eD3DFmtPixel, FALSE)))
|
|
continue;
|
|
|
|
if (D3DDEVTYPE_HAL==m_eD3DDevType)
|
|
{
|
|
isHALExists=TRUE;
|
|
|
|
if (m_kD3DCaps.Caps2 & D3DCAPS2_CANRENDERWINDOWED)
|
|
{
|
|
isHALWindowedCompatible=TRUE;
|
|
|
|
if (iFmt==0)
|
|
isHALDesktopCompatible=TRUE;
|
|
|
|
}
|
|
}
|
|
|
|
// Confirm the device/format for HW vertex processing
|
|
if (m_kD3DCaps.DevCaps & D3DDEVCAPS_HWTRANSFORMANDLIGHT)
|
|
{
|
|
if (m_kD3DCaps.DevCaps & D3DDEVCAPS_PUREDEVICE)
|
|
{
|
|
dwD3DBehavior=D3DCREATE_HARDWARE_VERTEXPROCESSING|D3DCREATE_PUREDEVICE;
|
|
|
|
if (pfnConfirmDevice(m_kD3DCaps, dwD3DBehavior, eD3DFmtPixel))
|
|
isFormatConfirmed = TRUE;
|
|
}
|
|
|
|
if (FALSE == isFormatConfirmed)
|
|
{
|
|
dwD3DBehavior = D3DCREATE_HARDWARE_VERTEXPROCESSING;
|
|
|
|
if (pfnConfirmDevice(m_kD3DCaps, dwD3DBehavior, eD3DFmtPixel))
|
|
isFormatConfirmed = TRUE;
|
|
}
|
|
|
|
if (FALSE == isFormatConfirmed)
|
|
{
|
|
dwD3DBehavior = D3DCREATE_MIXED_VERTEXPROCESSING;
|
|
|
|
if (pfnConfirmDevice(m_kD3DCaps, dwD3DBehavior, eD3DFmtPixel))
|
|
isFormatConfirmed = TRUE;
|
|
}
|
|
}
|
|
|
|
// Confirm the device/format for SW vertex processing
|
|
if (FALSE == isFormatConfirmed)
|
|
{
|
|
dwD3DBehavior = D3DCREATE_SOFTWARE_VERTEXPROCESSING;
|
|
|
|
if (pfnConfirmDevice(m_kD3DCaps, dwD3DBehavior, eD3DFmtPixel))
|
|
isFormatConfirmed = TRUE;
|
|
}
|
|
|
|
if (isFormatConfirmed)
|
|
{
|
|
if (!FindDepthStencilFormat(rkD3D, iD3DAdapterInfo, c_eD3DDevType, eD3DFmtPixel, &aeD3DFmtDepthStencil[iFmt]))
|
|
isFormatConfirmed = TRUE;
|
|
|
|
}
|
|
|
|
adwD3DBehavior[iFmt]=dwD3DBehavior;
|
|
aisFormatConfirmed[iFmt]=isFormatConfirmed;
|
|
}
|
|
}
|
|
|
|
// BuildModeInfoList
|
|
{
|
|
UINT uD3DDMNum=rkD3DADMList.GetDisplayModeNum();
|
|
UINT uD3DFmtNum=rkD3DADMList.GetPixelFormatNum();
|
|
|
|
|
|
for (UINT iD3DDM=0; iD3DDM<uD3DDMNum; ++iD3DDM)
|
|
{
|
|
const D3DDISPLAYMODE& c_rkD3DDM=rkD3DADMList.GetDisplayModer(iD3DDM);
|
|
for (DWORD iFmt=0; iFmt<uD3DFmtNum; ++iFmt)
|
|
{
|
|
if (rkD3DADMList.GetPixelFormatr(iFmt)==c_rkD3DDM.Format)
|
|
{
|
|
if (aisFormatConfirmed[iFmt] == TRUE )
|
|
{
|
|
D3D_SModeInfo& rkModeInfo=m_akD3DModeInfo[m_uD3DModeInfoNum++];
|
|
rkModeInfo.m_uScrWidth=c_rkD3DDM.Width;
|
|
rkModeInfo.m_uScrHeight=c_rkD3DDM.Height;
|
|
rkModeInfo.m_eD3DFmtPixel=c_rkD3DDM.Format;
|
|
rkModeInfo.m_dwD3DBehavior=adwD3DBehavior[iFmt];
|
|
rkModeInfo.m_eD3DFmtDepthStencil=aeD3DFmtDepthStencil[iFmt];
|
|
|
|
if( m_eD3DDevType == D3DDEVTYPE_HAL )
|
|
isHALSampleCompatible = TRUE;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// Check if the device is compatible with the desktop display mode
|
|
// (which was added initially as formats[0])
|
|
if (aisFormatConfirmed[0] && (m_kD3DCaps.Caps2 & D3DCAPS2_CANRENDERWINDOWED) )
|
|
{
|
|
m_canDoWindowed=TRUE;
|
|
m_isWindowed=TRUE;
|
|
}
|
|
|
|
if (m_uD3DModeInfoNum>0)
|
|
return TRUE;
|
|
|
|
return FALSE;
|
|
}
|
|
|
|
BOOL D3D_CDeviceInfo::Find(UINT uScrWidth, UINT uScrHeight, UINT uScrDepthBits, BOOL isWindowed, UINT* piD3DModeInfo)
|
|
{
|
|
if (isWindowed)
|
|
if (!m_isWindowed)
|
|
return FALSE;
|
|
|
|
for (UINT iD3D_SModeInfo=0; iD3D_SModeInfo<m_uD3DModeInfoNum; ++iD3D_SModeInfo)
|
|
{
|
|
D3D_SModeInfo& rkModeInfo=m_akD3DModeInfo[iD3D_SModeInfo];
|
|
if (rkModeInfo.m_uScrWidth==uScrWidth && rkModeInfo.m_uScrHeight==uScrHeight)
|
|
{
|
|
if (uScrDepthBits==16)
|
|
{
|
|
switch (rkModeInfo.m_eD3DFmtPixel)
|
|
{
|
|
case D3DFMT_R5G6B5:
|
|
case D3DFMT_X1R5G5B5:
|
|
case D3DFMT_A1R5G5B5:
|
|
*piD3DModeInfo=iD3D_SModeInfo;
|
|
return TRUE;
|
|
break;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
switch (rkModeInfo.m_eD3DFmtPixel)
|
|
{
|
|
case D3DFMT_X8R8G8B8:
|
|
case D3DFMT_A8R8G8B8:
|
|
case D3DFMT_R8G8B8:
|
|
*piD3DModeInfo=iD3D_SModeInfo;
|
|
return TRUE;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return FALSE;
|
|
}
|
|
|
|
VOID D3D_CDeviceInfo::GetString(std::string* pstEnumList)
|
|
{
|
|
char szText[1024+1];
|
|
_snprintf(szText, sizeof(szText), "%s\r\n========================================\r\n", m_szDevDesc);
|
|
pstEnumList->append(szText);
|
|
|
|
for (UINT iD3D_SModeInfo=0; iD3D_SModeInfo<m_uD3DModeInfoNum; ++iD3D_SModeInfo)
|
|
{
|
|
_snprintf(szText, sizeof(szText), "%d. ", iD3D_SModeInfo);
|
|
pstEnumList->append(szText);
|
|
|
|
D3D_SModeInfo& rkModeInfo=m_akD3DModeInfo[iD3D_SModeInfo];
|
|
rkModeInfo.GetString(pstEnumList);
|
|
}
|
|
|
|
pstEnumList->append("\r\n");
|
|
}
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
|
|
D3DDISPLAYMODE& D3D_CAdapterInfo::GetDesktopD3DDisplayModer()
|
|
{
|
|
return m_kD3DDMDesktop;
|
|
}
|
|
|
|
D3DDISPLAYMODE* D3D_CAdapterInfo::GetDesktopD3DDisplayModep()
|
|
{
|
|
return &m_kD3DDMDesktop;
|
|
}
|
|
|
|
D3D_CDeviceInfo* D3D_CAdapterInfo::GetD3DDeviceInfop(UINT iD3DDevInfo)
|
|
{
|
|
if (iD3DDevInfo >= m_uD3DDevInfoNum)
|
|
return NULL;
|
|
|
|
return &m_akD3DDevInfo[iD3DDevInfo];
|
|
}
|
|
|
|
D3D_SModeInfo* D3D_CAdapterInfo::GetD3DModeInfop(UINT iD3DDevInfo, UINT iD3D_SModeInfo)
|
|
{
|
|
D3D_CDeviceInfo* pkD3DDevInfo=GetD3DDeviceInfop(iD3DDevInfo);
|
|
if (pkD3DDevInfo)
|
|
{
|
|
D3D_SModeInfo* pkD3DModeInfo=pkD3DDevInfo->GetD3DModeInfop(iD3D_SModeInfo);
|
|
if (pkD3DModeInfo)
|
|
return pkD3DModeInfo;
|
|
}
|
|
return NULL;
|
|
}
|
|
|
|
BOOL D3D_CAdapterInfo::Find(UINT uScrWidth, UINT uScrHeight, UINT uScrDepthBits, BOOL isWindowed, UINT* piD3DModeInfo, UINT* piD3DDevInfo)
|
|
{
|
|
for (UINT iDevInfo=0; iDevInfo<m_uD3DDevInfoNum; ++iDevInfo)
|
|
{
|
|
D3D_CDeviceInfo& rkD3DDevInfo=m_akD3DDevInfo[iDevInfo];
|
|
if (rkD3DDevInfo.Find(uScrWidth, uScrHeight, uScrDepthBits, isWindowed, piD3DModeInfo))
|
|
{
|
|
*piD3DDevInfo=iDevInfo;
|
|
return TRUE;
|
|
}
|
|
}
|
|
return FALSE;
|
|
}
|
|
|
|
BOOL D3D_CAdapterInfo::Build(IDirect3D8& rkD3D, UINT iD3DAdapterInfo, PFNCONFIRMDEVICE pfnConfirmDevice)
|
|
{
|
|
D3DDISPLAYMODE& rkD3DDMDesktop=m_kD3DDMDesktop;
|
|
if (FAILED(rkD3D.GetAdapterDisplayMode(iD3DAdapterInfo, &rkD3DDMDesktop)))
|
|
return FALSE;
|
|
|
|
rkD3D.GetAdapterIdentifier(iD3DAdapterInfo, D3DENUM_NO_WHQL_LEVEL, &m_kD3DAdapterIdentifier);
|
|
|
|
m_iCurD3DDevInfo=0;
|
|
m_uD3DDevInfoNum=0;
|
|
|
|
D3D_CAdapterDisplayModeList kD3DADMList;
|
|
kD3DADMList.Build(rkD3D, m_kD3DDMDesktop.Format, iD3DAdapterInfo);
|
|
|
|
D3D_CDeviceInfo* akD3DDevInfo=m_akD3DDevInfo;
|
|
for (UINT iDevType=0; iDevType<D3DDEVICETYPE_NUM; ++iDevType)
|
|
{
|
|
D3D_CDeviceInfo& rkD3DDevInfo=akD3DDevInfo[m_uD3DDevInfoNum];
|
|
if (rkD3DDevInfo.Build(rkD3D, iD3DAdapterInfo, iDevType, kD3DADMList, pfnConfirmDevice))
|
|
++m_uD3DDevInfoNum;
|
|
}
|
|
|
|
if (m_uD3DDevInfoNum>0)
|
|
return TRUE;
|
|
|
|
return FALSE;
|
|
}
|
|
|
|
VOID D3D_CAdapterInfo::GetString(std::string* pstEnumList)
|
|
{
|
|
for (UINT iDevInfo=0; iDevInfo<m_uD3DDevInfoNum; ++iDevInfo)
|
|
{
|
|
char szText[1024+1];
|
|
_snprintf(szText, sizeof(szText), "Device %d\r\n", iDevInfo);
|
|
pstEnumList->append(szText);
|
|
|
|
D3D_CDeviceInfo& rkD3DDevInfo=m_akD3DDevInfo[iDevInfo];
|
|
rkD3DDevInfo.GetString(pstEnumList);
|
|
}
|
|
}
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
|
|
D3D_CDisplayModeAutoDetector::D3D_CDisplayModeAutoDetector()
|
|
{
|
|
m_uD3DAdapterInfoCount=0;
|
|
}
|
|
|
|
D3D_CDisplayModeAutoDetector::~D3D_CDisplayModeAutoDetector()
|
|
{
|
|
}
|
|
|
|
D3D_CAdapterInfo* D3D_CDisplayModeAutoDetector::GetD3DAdapterInfop(UINT iD3DAdapterInfo)
|
|
{
|
|
if (iD3DAdapterInfo >= m_uD3DAdapterInfoCount)
|
|
return NULL;
|
|
|
|
return &m_akD3DAdapterInfo[iD3DAdapterInfo];
|
|
}
|
|
|
|
D3D_SModeInfo* D3D_CDisplayModeAutoDetector::GetD3DModeInfop(UINT iD3DAdapterInfo, UINT iD3DDevInfo, UINT iD3D_SModeInfo)
|
|
{
|
|
D3D_CAdapterInfo* pkD3DAdapterInfo=GetD3DAdapterInfop(iD3DAdapterInfo);
|
|
if (pkD3DAdapterInfo)
|
|
{
|
|
D3D_CDeviceInfo* pkD3DDevInfo=pkD3DAdapterInfo->GetD3DDeviceInfop(iD3DDevInfo);
|
|
if (pkD3DDevInfo)
|
|
{
|
|
D3D_SModeInfo* pkD3D_SModeInfo=pkD3DDevInfo->GetD3DModeInfop(iD3D_SModeInfo);
|
|
if (pkD3D_SModeInfo)
|
|
return pkD3D_SModeInfo;
|
|
}
|
|
}
|
|
return NULL;
|
|
}
|
|
|
|
BOOL D3D_CDisplayModeAutoDetector::Find(UINT uScrWidth, UINT uScrHeight, UINT uScrDepthBits, BOOL isWindowed, UINT* piD3DModeInfo, UINT* piD3DDevInfo, UINT* piD3DAdapterInfo)
|
|
{
|
|
for (UINT iD3DAdapterInfo=0; iD3DAdapterInfo<m_uD3DAdapterInfoCount; ++iD3DAdapterInfo)
|
|
{
|
|
D3D_CAdapterInfo& rkAdapterInfo=m_akD3DAdapterInfo[iD3DAdapterInfo];
|
|
if (rkAdapterInfo.Find(uScrWidth, uScrHeight, uScrDepthBits, isWindowed, piD3DModeInfo, piD3DDevInfo))
|
|
{
|
|
*piD3DAdapterInfo=iD3DAdapterInfo;
|
|
return TRUE;
|
|
}
|
|
}
|
|
return FALSE;
|
|
}
|
|
|
|
BOOL D3D_CDisplayModeAutoDetector::Build(IDirect3D8& rkD3D, PFNCONFIRMDEVICE pfnConfirmDevice)
|
|
{
|
|
m_uD3DAdapterInfoCount=0;
|
|
|
|
UINT uTotalAdapterCount=rkD3D.GetAdapterCount();
|
|
uTotalAdapterCount=min(uTotalAdapterCount, D3DADAPTERINFO_NUM);
|
|
|
|
for (UINT iD3DAdapterInfo=0; iD3DAdapterInfo<uTotalAdapterCount; ++iD3DAdapterInfo)
|
|
{
|
|
D3D_CAdapterInfo& rkAdapterInfo=m_akD3DAdapterInfo[m_uD3DAdapterInfoCount];
|
|
if (rkAdapterInfo.Build(rkD3D, iD3DAdapterInfo, pfnConfirmDevice))
|
|
++m_uD3DAdapterInfoCount;
|
|
}
|
|
|
|
if (m_uD3DAdapterInfoCount>0)
|
|
return TRUE;
|
|
|
|
return FALSE;
|
|
}
|
|
|
|
VOID D3D_CDisplayModeAutoDetector::GetString(std::string* pstEnumList)
|
|
{
|
|
for (UINT iD3DAdapterInfo=0; iD3DAdapterInfo<m_uD3DAdapterInfoCount; ++iD3DAdapterInfo)
|
|
{
|
|
char szText[1024+1];
|
|
_snprintf(szText, sizeof(szText), "Adapter %d\r\n", iD3DAdapterInfo);
|
|
pstEnumList->append(szText);
|
|
|
|
D3D_CAdapterInfo& rkAdapterInfo=m_akD3DAdapterInfo[iD3DAdapterInfo];
|
|
rkAdapterInfo.GetString(pstEnumList);
|
|
}
|
|
} |