void fixup_caps(WINED3DCAPS *caps)
{
/* D3D8 doesn't support SM 2.0 or higher, so clamp to 1.x */
if (caps->PixelShaderVersion)
caps->PixelShaderVersion = D3DPS_VERSION(1,4);
else
caps->PixelShaderVersion = D3DPS_VERSION(0,0);
if (caps->VertexShaderVersion)
caps->VertexShaderVersion = D3DVS_VERSION(1,1);
else
caps->VertexShaderVersion = D3DVS_VERSION(0,0);
caps->MaxVertexShaderConst = min(D3D8_MAX_VERTEX_SHADER_CONSTANTF, caps->MaxVertexShaderConst);
caps->StencilCaps &= ~WINED3DSTENCILCAPS_TWOSIDED;
}
static void test_get_shader_version(void)
{
DWORD shader_version;
shader_version = D3DXGetShaderVersion(simple_vs);
ok(shader_version == D3DVS_VERSION(1, 1), "Got shader version 0x%08x, expected 0x%08x\n",
shader_version, D3DVS_VERSION(1, 1));
shader_version = D3DXGetShaderVersion(simple_ps);
ok(shader_version == D3DPS_VERSION(1, 1), "Got shader version 0x%08x, expected 0x%08x\n",
shader_version, D3DPS_VERSION(1, 1));
shader_version = D3DXGetShaderVersion(NULL);
ok(shader_version == 0, "Got shader version 0x%08x, expected 0\n", shader_version);
}
//=============================================================================================================
void Game::Reset(const std::string& stagefile)
{
Clear();
UnapplyPowerup();
savedvars.health = avatar.Health;
savedvars.maxhealth = avatar.MaxHealth;
savedvars.integrity = avatar.Integrity;
savedvars.maxintegrity = avatar.MaxIntegrity;
savedvars.score = hud.Score;
avatar.InitialPosition = D3DXVECTOR2(0, (GameVariables::ScreenHeight - avatar.Image->Size.y) * 0.5f);
avatar.Bounds = D3DXVECTOR4(0, hud.Panel->Size.y, GameVariables::ScreenWidth, GameVariables::ScreenHeight - hud.Panel->Size.y);
if( !distort && rendertarget && rendersurface && GameVariables::EnableShaders )
{
if( game->DeviceCaps.VertexShaderVersion >= D3DVS_VERSION(2, 0) &&
game->DeviceCaps.PixelShaderVersion >= D3DPS_VERSION(2, 0) )
{
distort = game->Content.LoadMaterial("distort.fx");
GameVariables::EnableShaders = (distort != NULL);
}
}
if( !script.Compile(stagefile, *this) )
game->Application.Close();
RestartLevel();
}
//-------------------------------------------------------------
// Name: ConfirmDevice()
// Desc: �ʱ�ȭ�� ȣ���. �ʿ��� �ɷ�(caps)üũ
//-------------------------------------------------------------
HRESULT CMyD3DApplication::ConfirmDevice( D3DCAPS9* pCaps,
DWORD dwBehavior, D3DFORMAT Format )
{
UNREFERENCED_PARAMETER( Format );
BOOL bCapsAcceptable;
// ���Ⱥ��尡 ���α��� ������ �ɷ��� �ִ°� Ȯ��
bCapsAcceptable = TRUE;
// �� �ȼ����̴� ����Ȯ��
if( pCaps->PixelShaderVersion < D3DPS_VERSION(1,1) )
bCapsAcceptable = FALSE;
// �������̴� ����Ȯ��
if( (dwBehavior & D3DCREATE_HARDWARE_VERTEXPROCESSING ) ||
(dwBehavior & D3DCREATE_MIXED_VERTEXPROCESSING ) )
{
if( pCaps->VertexShaderVersion < D3DVS_VERSION(1,1) )
bCapsAcceptable = FALSE;
}
if( bCapsAcceptable )
return S_OK;
else
return E_FAIL;
}
void D3D9VideoInfo::SetupShaderProfile()
{
if (m_caps.VertexShaderVersion >= D3DVS_VERSION(1,1))
m_lastVertexProfile = Shader::SP_MODEL_1;
if (m_caps.VertexShaderVersion >= D3DVS_VERSION(2,0))
m_lastVertexProfile = Shader::SP_MODEL_2;
if (m_caps.VertexShaderVersion >= D3DVS_VERSION(3,0))
m_lastVertexProfile = Shader::SP_MODEL_3;
if (m_caps.PixelShaderVersion >= D3DPS_VERSION(1,0))
m_lastPixelProfile = Shader::SP_MODEL_1;
if (m_caps.PixelShaderVersion >= D3DPS_VERSION(2,0))
m_lastPixelProfile = Shader::SP_MODEL_2;
if (m_caps.PixelShaderVersion >= D3DPS_VERSION(3,0))
m_lastPixelProfile = Shader::SP_MODEL_3;
}
//--------------------------------------------------------------------------------------
// Rejects any D3D9 devices that aren't acceptable to the app by returning false
//--------------------------------------------------------------------------------------
bool CALLBACK IsD3D9DeviceAcceptable( D3DCAPS9* pCaps, D3DFORMAT AdapterFormat,
D3DFORMAT BackBufferFormat, bool bWindowed, void* pUserContext )
{
// No fallback defined by this app, so reject any device that
// doesn't support at least ps2.0
if( pCaps->PixelShaderVersion < D3DPS_VERSION( 2, 0 ) )
return false;
return true;
}
bool init() {
term();
RECT rd;
GetClientRect(settings.handle, &rd);
state.width = rd.right;
state.height = rd.bottom;
lpd3d = Direct3DCreate9(D3D_SDK_VERSION);
if(!lpd3d) return false;
memset(&presentation, 0, sizeof(presentation));
presentation.Flags = D3DPRESENTFLAG_VIDEO;
presentation.SwapEffect = D3DSWAPEFFECT_FLIP;
presentation.hDeviceWindow = settings.handle;
presentation.BackBufferCount = 1;
presentation.MultiSampleType = D3DMULTISAMPLE_NONE;
presentation.MultiSampleQuality = 0;
presentation.EnableAutoDepthStencil = false;
presentation.AutoDepthStencilFormat = D3DFMT_UNKNOWN;
presentation.PresentationInterval = D3DPRESENT_INTERVAL_IMMEDIATE;
presentation.Windowed = true;
presentation.BackBufferFormat = D3DFMT_UNKNOWN;
presentation.BackBufferWidth = 0;
presentation.BackBufferHeight = 0;
if(lpd3d->CreateDevice(D3DADAPTER_DEFAULT, D3DDEVTYPE_HAL, settings.handle,
D3DCREATE_FPU_PRESERVE | D3DCREATE_SOFTWARE_VERTEXPROCESSING, &presentation, &device) != D3D_OK) {
return false;
}
device->GetDeviceCaps(&d3dcaps);
caps.dynamic = bool(d3dcaps.Caps2 & D3DCAPS2_DYNAMICTEXTURES);
caps.shader = d3dcaps.PixelShaderVersion > D3DPS_VERSION(1, 4);
if(caps.dynamic == true) {
flags.t_usage = D3DUSAGE_DYNAMIC;
flags.v_usage = D3DUSAGE_WRITEONLY | D3DUSAGE_DYNAMIC;
flags.t_pool = D3DPOOL_DEFAULT;
flags.v_pool = D3DPOOL_DEFAULT;
flags.lock = D3DLOCK_NOSYSLOCK | D3DLOCK_DISCARD;
} else {
flags.t_usage = 0;
flags.v_usage = D3DUSAGE_WRITEONLY;
flags.t_pool = D3DPOOL_MANAGED;
flags.v_pool = D3DPOOL_MANAGED;
flags.lock = D3DLOCK_NOSYSLOCK | D3DLOCK_DISCARD;
}
lost = false;
recover();
return true;
}
int D3D9DeviceCaps::PixelShaderVersion()
{
switch (mCaps.PixelShaderVersion)
{
case D3DPS_VERSION(3, 0):
return (int)SP_PS;
default:
return 0;
}
}
bool StencilMirrorDemo::checkDeviceCaps()
{
D3DCAPS9 caps;
HR(gd3dDevice->GetDeviceCaps(&caps));
if (caps.VertexShaderVersion < D3DVS_VERSION(2,0))
return false;
if (caps.PixelShaderVersion < D3DPS_VERSION(2,0))
return false;
return true;
}
// Only Direct3D 10 ready devices support all the necessary vertex texture formats.
// We test this using D3D9 by checking support for the R16F format.
bool Display::getVertexTextureSupport() const
{
if (!isInitialized() || mDeviceCaps.PixelShaderVersion < D3DPS_VERSION(3, 0))
{
return false;
}
D3DDISPLAYMODE currentDisplayMode;
mD3d9->GetAdapterDisplayMode(mAdapter, ¤tDisplayMode);
HRESULT result = mD3d9->CheckDeviceFormat(mAdapter, mDeviceType, currentDisplayMode.Format, D3DUSAGE_QUERY_VERTEXTEXTURE, D3DRTYPE_TEXTURE, D3DFMT_R16F);
return SUCCEEDED(result);
}
bool MultiTexDemo::checkDeviceCaps()
{
D3DCAPS9 caps;
HR(gd3dDevice->GetDeviceCaps(&caps));
// Check for vertex shader version 2.0 support.
if( caps.VertexShaderVersion < D3DVS_VERSION(2, 0) )
return false;
// Check for pixel shader version 2.0 support.
if( caps.PixelShaderVersion < D3DPS_VERSION(2, 0) )
return false;
return true;
}
void CWinRenderer::SelectRenderMethod()
{
if (CONF_FLAGS_FORMAT_MASK(m_flags) == CONF_FLAGS_FORMAT_DXVA)
{
m_renderMethod = RENDER_DXVA;
}
else
{
int requestedMethod = g_guiSettings.GetInt("videoplayer.rendermethod");
CLog::Log(LOGDEBUG, __FUNCTION__": Requested render method: %d", requestedMethod);
switch(requestedMethod)
{
case RENDER_METHOD_AUTO:
case RENDER_METHOD_D3D_PS:
// Try the pixel shaders support
if (m_deviceCaps.PixelShaderVersion >= D3DPS_VERSION(2, 0))
{
CTestShader* shader = new CTestShader;
if (shader->Create())
{
m_renderMethod = RENDER_PS;
shader->Release();
break;
}
else
{
CLog::Log(LOGNOTICE, "D3D: unable to load test shader - D3D installation is most likely incomplete");
g_application.m_guiDialogKaiToast.QueueNotification(CGUIDialogKaiToast::Warning, "DirectX", g_localizeStrings.Get(2101));
shader->Release();
}
}
else
{
CLog::Log(LOGNOTICE, "D3D: graphics adapter does not support Pixel Shaders 2.0");
}
CLog::Log(LOGNOTICE, "D3D: falling back to SW mode");
// drop through to software
case RENDER_METHOD_SOFTWARE:
default:
// So we'll do the color conversion in software.
m_renderMethod = RENDER_SW;
break;
}
}
RenderMethodDetail *rmdet = FindRenderMethod(m_renderMethod);
CLog::Log(LOGDEBUG, __FUNCTION__": Selected render method %d: %s", m_renderMethod, rmdet != NULL ? rmdet->name : "unknown");
}
/**-----------------------------------------------------------------------------
* Direct3D 초기화
*------------------------------------------------------------------------------
*/
HRESULT InitD3D( HWND hWnd )
{
// 디바이스를 생성하기위한 D3D객체 생성
if( NULL == ( g_pD3D = Direct3DCreate9( D3D_SDK_VERSION ) ) )
return E_FAIL;
// 디바이스를 생성할 구조체
// 복잡한 오브젝트를 그릴것이기때문에, 이번에는 Z버퍼가 필요하다.
D3DPRESENT_PARAMETERS d3dpp;
ZeroMemory( &d3dpp, sizeof(d3dpp) );
d3dpp.Windowed = TRUE;
d3dpp.SwapEffect = D3DSWAPEFFECT_DISCARD;
d3dpp.BackBufferFormat = D3DFMT_UNKNOWN;
d3dpp.EnableAutoDepthStencil = TRUE;
d3dpp.AutoDepthStencilFormat = D3DFMT_D16;
D3DCAPS9 caps;
DWORD dwPSProcess;
// 디바이스의 능력값(caps)을 읽어온다
g_pD3D->GetDeviceCaps( D3DADAPTER_DEFAULT, D3DDEVTYPE_HAL, &caps );
// 지원하는 픽셀쉐이더 버전이 1.0이하라면 REF드라이버를, 1.0이상이면 HW드라이버를 생성한다.
dwPSProcess = ( caps.PixelShaderVersion < D3DPS_VERSION(1,0) ) ? 0 : 1;
if( dwPSProcess )
{
if( FAILED( g_pD3D->CreateDevice( D3DADAPTER_DEFAULT, D3DDEVTYPE_HAL, hWnd,
D3DCREATE_HARDWARE_VERTEXPROCESSING,
&d3dpp, &g_pd3dDevice ) ) )
return E_FAIL;
}
else
{
if( FAILED( g_pD3D->CreateDevice( D3DADAPTER_DEFAULT, D3DDEVTYPE_REF, hWnd,
D3DCREATE_SOFTWARE_VERTEXPROCESSING,
&d3dpp, &g_pd3dDevice ) ) )
return E_FAIL;
}
// 기본컬링, CCW
g_pd3dDevice->SetRenderState( D3DRS_CULLMODE, D3DCULL_CCW );
// Z버퍼기능을 켠다.
g_pd3dDevice->SetRenderState( D3DRS_ZENABLE, TRUE );
return S_OK;
}
//--------------------------------------------------------------------------------------
// Rejects any D3D9 devices that aren't acceptable to the app by returning false
//--------------------------------------------------------------------------------------
bool CALLBACK IsDeviceAcceptable( D3DCAPS9* pCaps, D3DFORMAT AdapterFormat,
D3DFORMAT BackBufferFormat, bool bWindowed, void* pUserContext )
{
// No fallback, so need ps2.0
if( pCaps->PixelShaderVersion < D3DPS_VERSION( 2, 0 ) )
return false;
// Skip backbuffer formats that don't support alpha blending
IDirect3D9* pD3D = DXUTGetD3D9Object();
if( FAILED( pD3D->CheckDeviceFormat( pCaps->AdapterOrdinal, pCaps->DeviceType,
AdapterFormat, D3DUSAGE_QUERY_POSTPIXELSHADER_BLENDING,
D3DRTYPE_TEXTURE, BackBufferFormat ) ) )
return false;
return true;
}
/*==============================================================
* 设备能力检查。如果任何一项返回 false，则拒绝 HAL 设备
* IsD3D9DeviceAcceptable()
*==============================================================*/
bool CALLBACK IsD3D9DeviceAcceptable( D3DCAPS9* pCaps, D3DFORMAT AdapterFormat, D3DFORMAT BackBufferFormat,
bool /*bWindowed*/, void* /*pUserContext*/ )
{
// Typically want to skip back buffer formats that don't support alpha blending
IDirect3D9* pD3D = NNN::DXUTGetD3D9Object();
if( FAILED( pD3D->CheckDeviceFormat(pCaps->AdapterOrdinal, pCaps->DeviceType,
AdapterFormat, D3DUSAGE_QUERY_POSTPIXELSHADER_BLENDING,
D3DRTYPE_TEXTURE, BackBufferFormat) ) )
return false;
// No fallback defined by this app, so reject any device that doesn't support at least ps2.0
if( pCaps->PixelShaderVersion < D3DPS_VERSION( 2, 0 ) )
return false;
return true;
}
//-------------------------------------------------------------
// Name: ConfirmDevice()
// Desc: 초기화시 호출됨. 필요한 능력(caps)체크
//-------------------------------------------------------------
HRESULT CMyD3DApplication::ConfirmDevice( D3DCAPS9* pCaps,
DWORD dwBehavior, D3DFORMAT Format )
{
UNREFERENCED_PARAMETER( Format );
// 픽셀셰이더 버전확인
if( pCaps->PixelShaderVersion < D3DPS_VERSION(2,0) )
return E_FAIL;
// 정점셰이더 버전확인
if( pCaps->VertexShaderVersion < D3DVS_VERSION(1,1)
&& 0==(dwBehavior & D3DCREATE_SOFTWARE_VERTEXPROCESSING) )
return E_FAIL;
return S_OK;
}
// do any one-time device initialization
// NOTE: this is also needed after a device lost/reset
// to reset the scene status and ensure the default states are reset.
void Display::initializeDevice()
{
// Permanent non-default states
mDevice->SetRenderState(D3DRS_POINTSPRITEENABLE, TRUE);
mDevice->SetRenderState(D3DRS_LASTPIXEL, FALSE);
if (mDeviceCaps.PixelShaderVersion >= D3DPS_VERSION(3, 0))
{
mDevice->SetRenderState(D3DRS_POINTSIZE_MAX, (DWORD&)mDeviceCaps.MaxPointSize);
}
else
{
mDevice->SetRenderState(D3DRS_POINTSIZE_MAX, 0x3F800000); // 1.0f
}
mSceneStarted = false;
}
bool SkeletonClass::checkDeviceCaps()
{
D3DCAPS9 caps;
HR(gd3dDevice->GetDeviceCaps(&caps));
// Check for vertex shader version 2.0 support.
if (caps.VertexShaderVersion < D3DVS_VERSION(2, 0))
{
return false;
}
// Check for pixel shader version 2.0 support.
if (caps.PixelShaderVersion < D3DPS_VERSION(2, 0))
{
return false;
}
return true;
}
bool InitResourceDX9(void)
{
LPDIRECT3DDEVICE9 device = GutGetGraphicsDeviceDX9();
D3DCAPS9 caps;
device->GetDeviceCaps(&caps);
if ( caps.PixelShaderVersion < D3DPS_VERSION(3,0) )
{
printf("Requires Pixel Shader 3.0\n");
return false;
}
for ( int i=0; i<TEX_TEXTURES; i++ )
{
g_pTextures[i] = NULL;
g_pSurfaces[i] = NULL;
}
if ( !ReInitResourceDX9() )
return false;
g_pParticleFX = GutLoadFXShaderDX9("../../shaders/GPUParticle.fx");
if ( NULL==g_pParticleFX )
return false;
g_pParticleRenderFX = GutLoadFXShaderDX9("../../shaders/GPUParticle_render.fx");
if ( NULL==g_pParticleRenderFX )
return false;
g_pPostFX = GutLoadFXShaderDX9("../../shaders/Posteffect.fx");
if ( NULL==g_pPostFX )
return false;
g_pNoiseTexture = GutLoadTexture_DX9("../../textures/noise_512x512.tga");
if ( NULL==g_pNoiseTexture )
return false;
g_pParticleTexture = GutLoadTexture_DX9("../../textures/particle.tga");
if ( NULL==g_pParticleTexture )
return false;
return true;
}
//-------------------------------------------------------------
// Name: ConfirmDevice()
// Desc: ÃʱâȽà ȣÃâµÊ. ÇÊ¿äÇÑ ´É·Â(caps)üũ
//-------------------------------------------------------------
HRESULT CMyD3DApplication::ConfirmDevice( D3DCAPS9* pCaps,
DWORD dwBehavior, D3DFORMAT Format )
{
UNREFERENCED_PARAMETER( Format );
UNREFERENCED_PARAMETER( dwBehavior );
UNREFERENCED_PARAMETER( pCaps );
// Çȼ¿¼ÎÀÌ´õ ¹öÀüüũ
if( pCaps->PixelShaderVersion < D3DPS_VERSION(2,0) )
return E_FAIL;
// Á¤Á¡¼ÎÀÌ´õ ¹öÀüÀÌ ¸ÂÁö¾ÊÀ¸¸é ¼ÒÇÁÆ®¿þ¾î ó¸®
if( pCaps->VertexShaderVersion < D3DVS_VERSION(1,1)
&& 0==(dwBehavior & D3DCREATE_SOFTWARE_VERTEXPROCESSING) )
return E_FAIL;
return S_OK;
}
//--------------------------------------------------------------------------------------
// Rejects any D3D9 devices that aren't acceptable to the app by returning false
//--------------------------------------------------------------------------------------
bool RenderWin32DX9Imp::IsD3D9DeviceAcceptable( D3DCAPS9* pCaps, D3DFORMAT AdapterFormat,
D3DFORMAT BackBufferFormat, bool bWindowed, void* pUserContext )
{
// Skip backBuffer formats that don't support alpha blending
IDirect3D9* pD3D = DXUTGetD3D9Object();
if( FAILED( pD3D->CheckDeviceFormat( pCaps->AdapterOrdinal, pCaps->DeviceType,
AdapterFormat, D3DUSAGE_QUERY_POSTPIXELSHADER_BLENDING,
D3DRTYPE_TEXTURE, BackBufferFormat ) ) )
return false;
// No fallback defined by this app, so reject any device that
// doesn't support at least ps2.0
if( pCaps->PixelShaderVersion < D3DPS_VERSION( 2, 0 ) )
return false;
//if( pCaps->VertexShaderVersion < D3DVS_VERSION( 1, 1 ) )
// return false;
return true;
}
bool DirectxCheck::CheckShadder20(void)
{
IDirect3D9 *d3d;
D3DCAPS9 d3d9caps;
int count;
d3d = Direct3DCreate9(D3D_SDK_VERSION);
d3d->GetDeviceCaps(D3DADAPTER_DEFAULT,D3DDEVTYPE_HAL,&d3d9caps);
unsigned long temp;
temp = D3DPTFILTERCAPS_MAGFLINEAR | D3DPTFILTERCAPS_MINFLINEAR |D3DPTFILTERCAPS_MIPFLINEAR;
if( (d3d9caps.PixelShaderVersion >= D3DPS_VERSION(2,0)) && ((d3d9caps.TextureFilterCaps & temp) == temp) )
{
d3d->Release();
return true;
}
d3d->Release();
return false;
}
LPCSTR WINAPI D3DXGetPixelShaderProfile(LPDIRECT3DDEVICE9 device)
{
D3DCAPS9 caps;
TRACE("device %p\n", device);
if (!device) return NULL;
IDirect3DDevice9_GetDeviceCaps(device,&caps);
switch (caps.PixelShaderVersion)
{
case D3DPS_VERSION(1, 1):
return "ps_1_1";
case D3DPS_VERSION(1, 2):
return "ps_1_2";
case D3DPS_VERSION(1, 3):
return "ps_1_3";
case D3DPS_VERSION(1, 4):
return "ps_1_4";
case D3DPS_VERSION(2, 0):
if ((caps.PS20Caps.NumTemps>=22) &&
(caps.PS20Caps.Caps&D3DPS20CAPS_ARBITRARYSWIZZLE) &&
(caps.PS20Caps.Caps&D3DPS20CAPS_GRADIENTINSTRUCTIONS) &&
(caps.PS20Caps.Caps&D3DPS20CAPS_PREDICATION) &&
(caps.PS20Caps.Caps&D3DPS20CAPS_NODEPENDENTREADLIMIT) &&
(caps.PS20Caps.Caps&D3DPS20CAPS_NOTEXINSTRUCTIONLIMIT))
{
return "ps_2_a";
}
if ((caps.PS20Caps.NumTemps>=32) &&
(caps.PS20Caps.Caps&D3DPS20CAPS_NOTEXINSTRUCTIONLIMIT))
{
return "ps_2_b";
}
return "ps_2_0";
case D3DPS_VERSION(3, 0):
return "ps_3_0";
}
return NULL;
}
//--------------------------------------------------------------------------------------
// Called during device initialization, this code checks the device for some
// minimum set of capabilities, and rejects those that don't pass by returning false.
//--------------------------------------------------------------------------------------
bool CALLBACK IsDeviceAcceptable( D3DCAPS9* pCaps, D3DFORMAT AdapterFormat,
D3DFORMAT BackBufferFormat, bool bWindowed, void* pUserContext )
{
// Skip backbuffer formats that don't support alpha blending
IDirect3D9* pD3D = DXUTGetD3D9Object();
if( FAILED( pD3D->CheckDeviceFormat( pCaps->AdapterOrdinal, pCaps->DeviceType,
AdapterFormat, D3DUSAGE_QUERY_POSTPIXELSHADER_BLENDING,
D3DRTYPE_TEXTURE, BackBufferFormat ) ) )
return false;
// Determine texture support. Fail if not good enough
D3DFORMAT fmtTexture, fmtCubeMap;
GetSupportedTextureFormat( pD3D, pCaps, AdapterFormat, &fmtTexture, &fmtCubeMap );
if( D3DFMT_UNKNOWN == fmtTexture || D3DFMT_UNKNOWN == fmtCubeMap )
return false;
// This sample requires pixel shader 2.0, but does showcase techniques which will
// perform well on shader model 1.1 hardware.
if( pCaps->PixelShaderVersion < D3DPS_VERSION( 2, 0 ) )
return false;
return true;
}
void CWndOptVideo::OnInitialUpdate()
{
CWndNeuz::OnInitialUpdate();
CRect rectRoot = m_pWndRoot->GetLayoutRect();
CRect rectWindow = GetWindowRect();
CPoint point( rectRoot.right - rectWindow.Width(), 110 );
Move( point );
MoveParentCenter();
CWndButton* pWndButton[ 3 ];
pWndButton[ 0 ] = (CWndButton*)GetDlgItem( WIDC_OBJECT_LOD_HIGH );
pWndButton[ 1 ] = (CWndButton*)GetDlgItem( WIDC_OBJECT_LOD_MID );
pWndButton[ 2 ] = (CWndButton*)GetDlgItem( WIDC_OBJECT_LOD_LOW );
pWndButton[ 0 ]->SetGroup( TRUE );
pWndButton[ g_Option.m_nObjectDetail ]->SetCheck( TRUE );
pWndButton[ 0 ] = (CWndButton*)GetDlgItem( WIDC_OBJECT_DISTANT_HIGH );
pWndButton[ 1 ] = (CWndButton*)GetDlgItem( WIDC_OBJECT_DISTANT_MID );
pWndButton[ 2 ] = (CWndButton*)GetDlgItem( WIDC_OBJECT_DISTANT_LOW );
pWndButton[ 0 ]->SetGroup( TRUE );
pWndButton[ g_Option.m_nObjectDistant ]->SetCheck( TRUE );
pWndButton[ 0 ] = (CWndButton*)GetDlgItem( WIDC_TERRAIN_LOD_HIGH );
pWndButton[ 1 ] = (CWndButton*)GetDlgItem( WIDC_TERRAIN_LOD_MID );
pWndButton[ 2 ] = (CWndButton*)GetDlgItem( WIDC_TERRAIN_LOD_LOW );
pWndButton[ 0 ]->SetGroup( TRUE );
pWndButton[ g_Option.m_nViewArea ]->SetCheck( TRUE );
pWndButton[ 0 ] = (CWndButton*)GetDlgItem( WIDC_SHADOW_HIGH );
pWndButton[ 1 ] = (CWndButton*)GetDlgItem( WIDC_SHADOW_MID );
pWndButton[ 2 ] = (CWndButton*)GetDlgItem( WIDC_SHADOW_LOW );
pWndButton[ 0 ]->SetGroup( TRUE );
pWndButton[ g_Option.m_nShadow ]->SetCheck( TRUE );
if( g_Neuz.m_d3dCaps.MaxSimultaneousTextures <= 2 )
{
pWndButton[ 0 ]->EnableWindow( FALSE );
pWndButton[ 1 ]->EnableWindow( FALSE );
pWndButton[ 2 ]->EnableWindow( FALSE );
}
#ifdef __SFX_OPT
if( ::GetLanguage() == LANG_KOR || ::GetLanguage() == LANG_JAP)
{
pWndButton[ 0 ] = (CWndButton*)GetDlgItem( WIDC_CHECK4 );
if(pWndButton[ 0 ])
pWndButton[ 0 ]->SetVisible(FALSE);
}
#else
pWndButton[ 1 ] = (CWndButton*)GetDlgItem( WIDC_VOICEON );
pWndButton[ 0 ] = (CWndButton*)GetDlgItem( WIDC_VOICEOFF );
pWndButton[ 1 ]->SetGroup( TRUE );
pWndButton[ g_Option.m_bVoice ]->SetCheck( TRUE );
pWndButton[ 0 ] = (CWndButton*)GetDlgItem( WIDC_GLOWON );
pWndButton[ 1 ] = (CWndButton*)GetDlgItem( WIDC_GLOWOFF );
pWndButton[ 0 ]->SetGroup( TRUE );
if( g_Neuz.m_d3dCaps.PixelShaderVersion >= D3DPS_VERSION(1,1) )
{
pWndButton[ g_Option.m_nBloom^1 ]->SetCheck( TRUE );
} else
{
pWndButton[0]->EnableWindow( FALSE );
pWndButton[1]->EnableWindow( FALSE );
}
pWndButton[ 0 ] = (CWndButton*)GetDlgItem( WIDC_CHECK5 );
pWndButton[ 0 ]->SetCheck(!g_Option.m_bSFXRenderOff);
#endif
#ifdef __YENV
pWndButton[ 0 ] = (CWndButton*)GetDlgItem( WIDC_SEPCBUMPCHECK );
if( g_bUsableVS && g_dwUsablePS_Level == 2 )
{
pWndButton[0]->EnableWindow( TRUE );
}
else
{
pWndButton[0]->EnableWindow( FALSE );
}
if( g_Option.m_bSpecBump )
{
pWndButton[0]->SetCheck( TRUE );
}
else
{
pWndButton[0]->SetCheck( FALSE );
}
if( g_Neuz.m_bFakeFullMode )
{
pWndButton[ 0 ] = (CWndButton*)GetDlgItem( WIDC_CHECK4 );
if(pWndButton[ 0 ])
pWndButton[ 0 ]->SetCheck(!g_Option.m_bStartFullScreen);
}
#endif //__YENV
pWndButton[ 0 ] = (CWndButton*)GetDlgItem( WIDC_CHECK6 );
pWndButton[ 0 ]->SetCheck(g_Option.m_nPlayerName);
pWndButton[ 0 ] = (CWndButton*)GetDlgItem( WIDC_CHECK7 );
pWndButton[ 0 ]->SetCheck(g_Option.m_nOtherPlayerName);
pWndButton[ 0 ] = (CWndButton*)GetDlgItem( WIDC_CHECK8 );
pWndButton[ 0 ]->SetCheck(g_Option.m_nMonName);
pWndButton[ 0 ] = (CWndButton*)GetDlgItem( WIDC_CHECK2 );
pWndButton[ 0 ]->SetCheck(g_Option.m_bDamageRender);
#if __VER >= 12 // __UPDATE_OPT
pWndButton[ 0 ] = (CWndButton*)GetDlgItem( WIDC_CHECK1);
pWndButton[ 0 ]->SetCheck(!g_Option.m_bZoomLimit);
pWndButton[ 0 ] = (CWndButton*)GetDlgItem( WIDC_VIEWMASK );
pWndButton[ 0 ]->SetCheck(g_Option.m_bViewMask);
if(g_pPlayer && g_pPlayer->IsOptionRenderMask() != g_Option.m_bViewMask)
g_DPlay.SendOptionEnableRenderMask( g_Option.m_bViewMask );
pWndButton[ 0 ] = (CWndButton*)GetDlgItem( WIDC_CHECK5 );
if(pWndButton[ 0 ])
pWndButton[ 0 ]->SetCheck( g_Option.m_bCameraLock );
#else
pWndButton[ 0 ] = (CWndButton*)GetDlgItem( WIDC_VISIBLEKEEPTIME );
pWndButton[ 0 ]->SetCheck(g_Option.m_bVisibleBuffTimeRender);
#endif
m_Texture.LoadTexture( g_Neuz.GetDevice(), MakePath( DIR_THEME, "WndVolumeBar.tga" ), 0xffff00ff, TRUE );
m_TexturePt.LoadTexture( g_Neuz.GetDevice(), MakePath( DIR_THEME, "ButtSpin.tga" ), 0xffffffff, TRUE );
#ifdef __SFX_OPT
m_nStep[0] = g_Option.m_nSfxLevel;
m_nStep[1] = !g_Option.m_bSFXRenderOff;
#else
pWndButton[ 0 ] = (CWndButton*)GetDlgItem( WIDC_MOUSE_HIGH );
pWndButton[ 1 ] = (CWndButton*)GetDlgItem( WIDC_MOUSE_MID );
pWndButton[ 2 ] = (CWndButton*)GetDlgItem( WIDC_MOUSE_LOW );
pWndButton[ 0 ]->SetGroup( TRUE );
pWndButton[ g_Option.m_MouseSpeed ]->SetCheck( TRUE );
m_nStep[0] = g_Option.m_fEffectVolume * 10;
m_nStep[1] = g_Option.m_fBGMVolume * 10;
#endif
pWndButton[ 0 ] = (CWndButton*)GetDlgItem( WIDC_CHECK3 );
if(pWndButton[ 0 ]) pWndButton[ 0 ]->SetCheck(g_Option.m_nWeatherEffect);
#if __VER <= 8 //__Y_GAMMA_CONTROL_8
m_nBrightTable[0] = -40;
m_nBrightTable[1] = -30;
m_nBrightTable[2] = -20;
m_nBrightTable[3] = -10;
m_nBrightTable[4] = 0;
m_nBrightTable[5] = 10;
m_nBrightTable[6] = 20;
m_nBrightTable[7] = 30;
m_nBrightTable[8] = 40;
m_nBrightTable[9] = 50;
m_nBrightTable[10] = 60;
for( int i=0; i<11; i++ )
{
if( m_nBrightTable[i] == g_Option.m_nOverBright )
{
m_nStep[3] = i;
break;
}
}
m_nStep[2] = (int)( g_Option.m_fGamma * 5 );
m_nStep[4] = (int)( g_Option.m_fContrast * 5 );
#endif //__Y_GAMMA_CONTROL_8
}
BOOL CWndOptVideo::OnChildNotify( UINT message, UINT nID, LRESULT* pLResult )
{
CWndButton* pWndButton = (CWndButton*)*pLResult;
CWndButton* pWndZoomLimit = (CWndButton*)GetDlgItem( WIDC_CHECK1 );
#if __VER >= 12 // __UPDATE_OPT
CWndButton* pWndCamearaLock = (CWndButton*)GetDlgItem( WIDC_CHECK5 );
#endif
switch( nID )
{
case WIDC_OBJECT_LOD_HIGH:
g_Option.m_nObjectDetail = 0;
break;
case WIDC_OBJECT_LOD_MID:
g_Option.m_nObjectDetail = 1;
break;
case WIDC_OBJECT_LOD_LOW:
g_Option.m_nObjectDetail = 2;
break;
case WIDC_OBJECT_DISTANT_HIGH:
g_Option.m_nObjectDistant = 0;
break;
case WIDC_OBJECT_DISTANT_MID:
g_Option.m_nObjectDistant = 1;
break;
case WIDC_OBJECT_DISTANT_LOW:
g_Option.m_nObjectDistant = 2;
break;
case WIDC_TERRAIN_LOD_HIGH:
g_Option.m_nViewArea = 0;
SetLODDetail( g_Option.m_nViewArea );
break;
case WIDC_TERRAIN_LOD_MID:
g_Option.m_nViewArea = 1;
SetLODDetail( g_Option.m_nViewArea );
break;
case WIDC_TERRAIN_LOD_LOW:
g_Option.m_nViewArea = 2;
SetLODDetail( g_Option.m_nViewArea );
break;
case WIDC_SHADOW_HIGH:
g_Option.m_nShadow = 0;
CreateShadowMap( m_pApp->m_pd3dDevice, g_Neuz.m_d3dpp.BackBufferFormat );
break;
case WIDC_SHADOW_MID:
g_Option.m_nShadow = 1;
CreateShadowMap( m_pApp->m_pd3dDevice, g_Neuz.m_d3dpp.BackBufferFormat );
break;
case WIDC_SHADOW_LOW:
g_Option.m_nShadow = 2;
break;
#ifdef __SFX_OPT
case WIDC_CHECK4:
if( g_Neuz.m_bFakeFullMode && ::GetLanguage() != LANG_KOR)
{
pWndButton = (CWndButton*)GetDlgItem( WIDC_CHECK4 );
if(pWndButton)
{
g_Option.m_bStartFullScreen = !(pWndButton->GetCheck());
g_WndMng.OpenMessageBox( prj.GetText(TID_GAME_GAME_RESETTING), MB_OK, this );
}
}
break;
#else
case WIDC_GLOWON:
if( g_Neuz.m_d3dCaps.PixelShaderVersion >= D3DPS_VERSION(1,1) )
{
g_Option.m_nBloom = 1;
g_Glare.Create( D3DDEVICE, D3DFMT_R5G6B5, g_Option.m_nResWidth, g_Option.m_nResHeight - 48 );
}
break;
case WIDC_GLOWOFF:
g_Option.m_nBloom = 0;
break;
case WIDC_VOICEON:
g_Option.m_bVoice = 1;
break;
case WIDC_VOICEOFF:
g_Option.m_bVoice = 0;
break;
case WIDC_CHECK5:
pWndButton = (CWndButton*)GetDlgItem( WIDC_CHECK5 );
g_Option.m_bSFXRenderOff = !pWndButton->GetCheck();
break;
case WIDC_MOUSE_HIGH:
g_Option.m_MouseSpeed = 0;
break;
case WIDC_MOUSE_MID:
g_Option.m_MouseSpeed = 1;
break;
case WIDC_MOUSE_LOW:
g_Option.m_MouseSpeed = 2;
break;
case WIDC_CHECK4:
if( g_Neuz.m_bFakeFullMode )
{
pWndButton = (CWndButton*)GetDlgItem( WIDC_CHECK4 );
g_Option.m_bStartFullScreen = !(pWndButton->GetCheck());
g_WndMng.OpenMessageBox( prj.GetText(TID_GAME_GAME_RESETTING), MB_OK, this );
}
break;
#endif
#ifdef __YENV
case WIDC_SEPCBUMPCHECK:
// ¼³Á¤°ªÀ» ¹Ù·Î Àû¿ëÇϴ°ÍÀÌ ¾Æ´Ï¶ó Á¾·áÇÒ¶§ Àû¿ëÇÑ´Ù
// ¿É¼ÇÁß ´Ù½Ã ½ÃÀÛÇØ¾ß Àû¿ëµÇ´Â°ÍµéÀ» À§ÇÑ º¯¼ö..( ¹üÇÁ¸Ê... )
pWndButton = (CWndButton*)GetDlgItem( WIDC_SEPCBUMPCHECK );
if( pWndButton->GetCheck() != g_Option.m_bSpecBump )
{
g_Option.m_bExitChange = TRUE;
g_WndMng.OpenMessageBox( prj.GetText(TID_GAME_GAME_RESETTING), MB_OK, this );
}
else
g_Option.m_bExitChange = FALSE;
break;
#endif //__YENV
case WIDC_CHECK2:
pWndButton = (CWndButton*)GetDlgItem( WIDC_CHECK2 );
g_Option.m_bDamageRender = pWndButton->GetCheck();
break;
case WIDC_CHECK6:
pWndButton = (CWndButton*)GetDlgItem( WIDC_CHECK6 );
g_Option.m_nPlayerName = pWndButton->GetCheck();
break;
case WIDC_CHECK7:
pWndButton = (CWndButton*)GetDlgItem( WIDC_CHECK7 );
g_Option.m_nOtherPlayerName = pWndButton->GetCheck();
break;
case WIDC_CHECK8:
pWndButton = (CWndButton*)GetDlgItem( WIDC_CHECK8 );
g_Option.m_nMonName = pWndButton->GetCheck();
break;
#if __VER >= 12 // __UPDATE_OPT
case WIDC_CHECK1:
{
if( pWndZoomLimit->GetCheck() )
g_Option.m_bZoomLimit = FALSE;
else
g_Option.m_bZoomLimit = TRUE;
}
break;
case WIDC_VIEWMASK:
pWndButton = (CWndButton*)GetDlgItem( WIDC_VIEWMASK );
g_Option.m_bViewMask = pWndButton->GetCheck();
g_DPlay.SendOptionEnableRenderMask( pWndButton->GetCheck() );
break;
case WIDC_CHECK5:
{
if( pWndCamearaLock->GetCheck() )
g_Option.m_bCameraLock = TRUE;
else
g_Option.m_bCameraLock = FALSE;
}
break;
#else
case WIDC_VISIBLEKEEPTIME:
pWndButton = (CWndButton*)GetDlgItem( WIDC_VISIBLEKEEPTIME );
g_Option.m_bVisibleBuffTimeRender = pWndButton->GetCheck();
break;
#endif
case WIDC_CHECK3:
pWndButton = (CWndButton*)GetDlgItem( WIDC_CHECK3 );
if(pWndButton) g_Option.m_nWeatherEffect = pWndButton->GetCheck();
break;
/*
case WIDC_EFFECTONOFF:
{
CWndButton* pButton = (CWndButton*)GetDlgItem(WIDC_EFFECTONOFF);
g_Option.m_bEffect = pButton->GetCheck();
pButton->SetCheck( g_Option.m_bEffect );
}
break;
case WIDC_BMGONOFF:
{
CWndButton* pButton = (CWndButton*)GetDlgItem(WIDC_BMGONOFF);
g_Option.m_bMusic = pButton->GetCheck();
pButton->SetCheck( g_Option.m_bMusic );
// À½¾Ç ²ô°í Äѱâ
SetOn( g_Option.m_bMusic );
}
break;
*/
/*
case WIDC_SOUND_ON:
g_Option.m_nSoundEffect = g_SoundMng.m_nSoundVolume = 1;
break;
case WIDC_SOUND_OFF:
g_Option.m_nSoundEffect = g_SoundMng.m_nSoundVolume = 0;
break;
case WIDC_MUSIC_ON:
g_Option.m_fMusicVolume = 1.0f;
SetVolume( 1.0f );
break;
case WIDC_MUSIC_OFF:
g_Option.m_fMusicVolume = 0.0f;
SetVolume( 0.0f );
break;
*/
case WIDC_OK:
Destroy();
}
return CWndNeuz::OnChildNotify( message, nID, pLResult );
}
HRESULT STDMETHODCALLTYPE C9::GetDeviceCaps(UINT Adapter,D3DDEVTYPE DeviceType,D3DCAPS9 *pCaps)
{
/*
https://www.khronos.org/registry/vulkan/specs/1.0/xhtml/vkspec.html#VkPhysicalDeviceProperties
https://msdn.microsoft.com/en-us/library/windows/desktop/bb172513(v=vs.85).aspx
https://msdn.microsoft.com/en-us/library/windows/desktop/bb172635(v=vs.85).aspx
https://msdn.microsoft.com/en-us/library/windows/desktop/bb172591(v=vs.85).aspx
*/
//Fetch the properties & features from the physical device.
VkPhysicalDeviceProperties properties;
VkPhysicalDeviceFeatures features;
vkGetPhysicalDeviceProperties(this->mPhysicalDevices[Adapter], &properties);
vkGetPhysicalDeviceFeatures(this->mPhysicalDevices[Adapter], &features);
//Translate the vulkan properties & features into D3D9 capabilities.
pCaps->DeviceType = DeviceType;
pCaps->AdapterOrdinal=0;
pCaps->Caps=0;
pCaps->Caps2 = D3DCAPS2_CANMANAGERESOURCE | D3DCAPS2_DYNAMICTEXTURES | D3DCAPS2_FULLSCREENGAMMA | D3DCAPS2_CANAUTOGENMIPMAP;
pCaps->Caps3 = D3DCAPS3_ALPHA_FULLSCREEN_FLIP_OR_DISCARD | D3DCAPS3_COPY_TO_VIDMEM | D3DCAPS3_COPY_TO_SYSTEMMEM | D3DCAPS3_LINEAR_TO_SRGB_PRESENTATION;
pCaps->PresentationIntervals = D3DPRESENT_INTERVAL_DEFAULT | D3DPRESENT_INTERVAL_ONE | D3DPRESENT_INTERVAL_TWO | D3DPRESENT_INTERVAL_THREE | D3DPRESENT_INTERVAL_FOUR | D3DPRESENT_INTERVAL_IMMEDIATE;
pCaps->CursorCaps = D3DCURSORCAPS_COLOR | D3DCURSORCAPS_LOWRES;
pCaps->DevCaps = D3DDEVCAPS_CANBLTSYSTONONLOCAL | D3DDEVCAPS_CANRENDERAFTERFLIP | D3DDEVCAPS_DRAWPRIMITIVES2 | D3DDEVCAPS_DRAWPRIMITIVES2EX | D3DDEVCAPS_DRAWPRIMTLVERTEX | D3DDEVCAPS_EXECUTESYSTEMMEMORY | D3DDEVCAPS_EXECUTEVIDEOMEMORY | D3DDEVCAPS_HWRASTERIZATION | D3DDEVCAPS_HWTRANSFORMANDLIGHT | D3DDEVCAPS_PUREDEVICE | D3DDEVCAPS_TEXTURENONLOCALVIDMEM | D3DDEVCAPS_TEXTUREVIDEOMEMORY | D3DDEVCAPS_TLVERTEXSYSTEMMEMORY | D3DDEVCAPS_TLVERTEXVIDEOMEMORY;
pCaps->PrimitiveMiscCaps = D3DPMISCCAPS_MASKZ | D3DPMISCCAPS_CULLNONE | D3DPMISCCAPS_CULLCW | D3DPMISCCAPS_CULLCCW | D3DPMISCCAPS_COLORWRITEENABLE | D3DPMISCCAPS_CLIPPLANESCALEDPOINTS | D3DPMISCCAPS_TSSARGTEMP | D3DPMISCCAPS_BLENDOP | D3DPMISCCAPS_INDEPENDENTWRITEMASKS | D3DPMISCCAPS_FOGANDSPECULARALPHA | D3DPMISCCAPS_SEPARATEALPHABLEND | D3DPMISCCAPS_MRTINDEPENDENTBITDEPTHS | D3DPMISCCAPS_MRTPOSTPIXELSHADERBLENDING | D3DPMISCCAPS_FOGVERTEXCLAMPED;
pCaps->RasterCaps = D3DPRASTERCAPS_ANISOTROPY | D3DPRASTERCAPS_COLORPERSPECTIVE | D3DPRASTERCAPS_DITHER | D3DPRASTERCAPS_DEPTHBIAS | D3DPRASTERCAPS_FOGRANGE | D3DPRASTERCAPS_FOGTABLE | D3DPRASTERCAPS_FOGVERTEX | D3DPRASTERCAPS_MIPMAPLODBIAS | D3DPRASTERCAPS_MULTISAMPLE_TOGGLE | D3DPRASTERCAPS_SCISSORTEST | D3DPRASTERCAPS_SLOPESCALEDEPTHBIAS | D3DPRASTERCAPS_WFOG | D3DPRASTERCAPS_ZFOG | D3DPRASTERCAPS_ZTEST;
pCaps->ZCmpCaps = D3DPCMPCAPS_NEVER | D3DPCMPCAPS_LESS | D3DPCMPCAPS_EQUAL | D3DPCMPCAPS_LESSEQUAL | D3DPCMPCAPS_GREATER | D3DPCMPCAPS_NOTEQUAL | D3DPCMPCAPS_GREATEREQUAL | D3DPCMPCAPS_ALWAYS;
pCaps->SrcBlendCaps = D3DPBLENDCAPS_ZERO | D3DPBLENDCAPS_ONE | D3DPBLENDCAPS_SRCCOLOR | D3DPBLENDCAPS_INVSRCCOLOR | D3DPBLENDCAPS_SRCALPHA | D3DPBLENDCAPS_INVSRCALPHA | D3DPBLENDCAPS_DESTALPHA | D3DPBLENDCAPS_INVDESTALPHA | D3DPBLENDCAPS_DESTCOLOR | D3DPBLENDCAPS_INVDESTCOLOR | D3DPBLENDCAPS_SRCALPHASAT | D3DPBLENDCAPS_BOTHSRCALPHA | D3DPBLENDCAPS_BOTHINVSRCALPHA | D3DPBLENDCAPS_BLENDFACTOR | D3DPBLENDCAPS_INVSRCCOLOR2 | D3DPBLENDCAPS_SRCCOLOR2;
pCaps->DestBlendCaps = pCaps->SrcBlendCaps;
pCaps->AlphaCmpCaps = D3DPCMPCAPS_NEVER | D3DPCMPCAPS_LESS | D3DPCMPCAPS_EQUAL | D3DPCMPCAPS_LESSEQUAL | D3DPCMPCAPS_GREATER | D3DPCMPCAPS_NOTEQUAL | D3DPCMPCAPS_GREATEREQUAL | D3DPCMPCAPS_ALWAYS;
pCaps->ShadeCaps = D3DPSHADECAPS_COLORGOURAUDRGB | D3DPSHADECAPS_SPECULARGOURAUDRGB | D3DPSHADECAPS_ALPHAGOURAUDBLEND | D3DPSHADECAPS_FOGGOURAUD;
pCaps->TextureCaps = D3DPTEXTURECAPS_ALPHA | D3DPTEXTURECAPS_ALPHAPALETTE | D3DPTEXTURECAPS_PERSPECTIVE | D3DPTEXTURECAPS_PROJECTED | D3DPTEXTURECAPS_CUBEMAP | D3DPTEXTURECAPS_VOLUMEMAP | D3DPTEXTURECAPS_POW2 | D3DPTEXTURECAPS_NONPOW2CONDITIONAL | D3DPTEXTURECAPS_CUBEMAP_POW2 | D3DPTEXTURECAPS_VOLUMEMAP_POW2 | D3DPTEXTURECAPS_MIPMAP | D3DPTEXTURECAPS_MIPVOLUMEMAP | D3DPTEXTURECAPS_MIPCUBEMAP;
pCaps->TextureFilterCaps = D3DPTFILTERCAPS_MINFPOINT | D3DPTFILTERCAPS_MINFLINEAR | D3DPTFILTERCAPS_MINFANISOTROPIC | D3DPTFILTERCAPS_MIPFPOINT | D3DPTFILTERCAPS_MIPFLINEAR | D3DPTFILTERCAPS_MAGFPOINT | D3DPTFILTERCAPS_MAGFLINEAR | D3DPTFILTERCAPS_MAGFANISOTROPIC;
pCaps->CubeTextureFilterCaps = pCaps->TextureFilterCaps;
pCaps->VolumeTextureFilterCaps = pCaps->TextureFilterCaps;
pCaps->TextureAddressCaps = D3DPTADDRESSCAPS_BORDER | D3DPTADDRESSCAPS_INDEPENDENTUV | D3DPTADDRESSCAPS_WRAP | D3DPTADDRESSCAPS_MIRROR | D3DPTADDRESSCAPS_CLAMP | D3DPTADDRESSCAPS_MIRRORONCE;
pCaps->VolumeTextureAddressCaps = pCaps->TextureAddressCaps;
pCaps->LineCaps = D3DLINECAPS_ALPHACMP | D3DLINECAPS_BLEND | D3DLINECAPS_TEXTURE | D3DLINECAPS_ZTEST | D3DLINECAPS_FOG;
pCaps->MaxTextureWidth = properties.limits.maxImageDimension2D; //Revisit
pCaps->MaxTextureHeight = properties.limits.maxImageDimension2D; //Revisit
pCaps->MaxVolumeExtent= properties.limits.maxImageDimensionCube; //Revisit
pCaps->MaxTextureRepeat= 32768; //revisit
pCaps->MaxTextureAspectRatio = pCaps->MaxTextureWidth;
pCaps->MaxAnisotropy= features.samplerAnisotropy;
pCaps->MaxVertexW = 1e10f; //revisit
pCaps->GuardBandLeft = -1e9f; //revisit
pCaps->GuardBandTop = -1e9f; //revisit
pCaps->GuardBandRight = 1e9f; //revisit
pCaps->GuardBandBottom = 1e9f; //revisit
pCaps->ExtentsAdjust = 0.0f; //revisit
pCaps->StencilCaps = D3DSTENCILCAPS_KEEP | D3DSTENCILCAPS_ZERO | D3DSTENCILCAPS_REPLACE | D3DSTENCILCAPS_INCRSAT | D3DSTENCILCAPS_DECRSAT | D3DSTENCILCAPS_INVERT | D3DSTENCILCAPS_INCR | D3DSTENCILCAPS_DECR | D3DSTENCILCAPS_TWOSIDED;
pCaps->FVFCaps = D3DFVFCAPS_PSIZE;
pCaps->TextureOpCaps = D3DTEXOPCAPS_DISABLE | 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 | D3DTEXOPCAPS_BLENDTEXTUREALPHAPM | D3DTEXOPCAPS_BLENDCURRENTALPHA | D3DTEXOPCAPS_PREMODULATE | D3DTEXOPCAPS_MODULATEALPHA_ADDCOLOR | D3DTEXOPCAPS_MODULATECOLOR_ADDALPHA | D3DTEXOPCAPS_MODULATEINVALPHA_ADDCOLOR | D3DTEXOPCAPS_MODULATEINVCOLOR_ADDALPHA | D3DTEXOPCAPS_BUMPENVMAP | D3DTEXOPCAPS_BUMPENVMAPLUMINANCE | D3DTEXOPCAPS_DOTPRODUCT3 | D3DTEXOPCAPS_MULTIPLYADD | D3DTEXOPCAPS_LERP;
pCaps->MaxTextureBlendStages = properties.limits.maxDescriptorSetSamplers; //revisit
pCaps->MaxSimultaneousTextures= properties.limits.maxDescriptorSetSampledImages; //revisit
pCaps->VertexProcessingCaps = D3DVTXPCAPS_TEXGEN | D3DVTXPCAPS_MATERIALSOURCE7 | D3DVTXPCAPS_DIRECTIONALLIGHTS | D3DVTXPCAPS_POSITIONALLIGHTS | D3DVTXPCAPS_LOCALVIEWER | D3DVTXPCAPS_TWEENING;
pCaps->MaxActiveLights=0; //Revsit should be infinite but games may not read it that way.
pCaps->MaxUserClipPlanes = 8; //revisit
pCaps->MaxVertexBlendMatrices = 4; //revisit
pCaps->MaxVertexBlendMatrixIndex = 7; //revisit
pCaps->MaxPointSize= properties.limits.pointSizeRange[1]; //revisit
pCaps->MaxPrimitiveCount = 0xFFFFFFFF; //revisit
pCaps->MaxVertexIndex = 0xFFFFFFFF; //revisit
pCaps->MaxStreams = properties.limits.maxVertexInputBindings; //revisit
pCaps->MaxStreamStride= properties.limits.maxVertexInputBindingStride; //revisit
pCaps->VertexShaderVersion= D3DVS_VERSION(3, 0);
pCaps->MaxVertexShaderConst=256; //revisit
pCaps->PixelShaderVersion = D3DPS_VERSION(3, 0);
pCaps->PixelShader1xMaxValue = 65504.f;
pCaps->DevCaps2 = D3DDEVCAPS2_STREAMOFFSET | D3DDEVCAPS2_VERTEXELEMENTSCANSHARESTREAMOFFSET | D3DDEVCAPS2_CAN_STRETCHRECT_FROM_TEXTURES;
pCaps->MasterAdapterOrdinal=0;
pCaps->AdapterOrdinalInGroup=0;
pCaps->NumberOfAdaptersInGroup = 1;
pCaps->DeclTypes= D3DDTCAPS_UBYTE4 | D3DDTCAPS_UBYTE4N | D3DDTCAPS_SHORT2N | D3DDTCAPS_SHORT4N | D3DDTCAPS_USHORT2N | D3DDTCAPS_USHORT4N | D3DDTCAPS_UDEC3 | D3DDTCAPS_DEC3N | D3DDTCAPS_FLOAT16_2 | D3DDTCAPS_FLOAT16_4;
pCaps->NumSimultaneousRTs = 4; //revisit
pCaps->StretchRectFilterCaps= D3DPTFILTERCAPS_MINFPOINT | D3DPTFILTERCAPS_MINFLINEAR | D3DPTFILTERCAPS_MAGFPOINT | D3DPTFILTERCAPS_MAGFLINEAR;
pCaps->VS20Caps.Caps = D3DVS20CAPS_PREDICATION;
pCaps->VS20Caps.DynamicFlowControlDepth = 24; //revsit
pCaps->VS20Caps.StaticFlowControlDepth = 4; //revsit
pCaps->VS20Caps.NumTemps = 32; //revsit
pCaps->PS20Caps.Caps = D3DPS20CAPS_ARBITRARYSWIZZLE | D3DPS20CAPS_GRADIENTINSTRUCTIONS | D3DPS20CAPS_PREDICATION;
pCaps->PS20Caps.DynamicFlowControlDepth = 24; //revsit
pCaps->PS20Caps.StaticFlowControlDepth = 4; //revsit
pCaps->PS20Caps.NumTemps = 32; //revsit
pCaps->VertexTextureFilterCaps = pCaps->TextureFilterCaps; //revisit
pCaps->MaxVertexShader30InstructionSlots = 32768; //revisit
pCaps->MaxPixelShader30InstructionSlots = 32768; //revisit
pCaps->MaxVShaderInstructionsExecuted = 65535 < pCaps->MaxVertexShader30InstructionSlots * 32 ? pCaps->MaxVertexShader30InstructionSlots * 32: 65535; //revisit
pCaps->MaxPShaderInstructionsExecuted = 65535 < pCaps->MaxPixelShader30InstructionSlots * 32 ? pCaps->MaxPixelShader30InstructionSlots * 32 : 65535; //revisit
pCaps->MaxNpatchTessellationLevel = 0.0f;
pCaps->Reserved5 = 0;
return S_OK;
}
bool D3D9Renderer::SupportsSM2() {
D3DCAPS9 Caps;
m_D3DDevice->GetDeviceCaps(&Caps);
return (Caps.PixelShaderVersion >= D3DPS_VERSION(2, 0) &&
Caps.VertexShaderVersion >= D3DVS_VERSION(2, 0));
}
void GenerateCaps(IDirect3D9 *d3d9, IDirect3DDevice9 *device, D3DDEVTYPE deviceType, UINT adapter, gl::Caps *caps,
gl::TextureCapsMap *textureCapsMap, gl::Extensions *extensions)
{
D3DCAPS9 deviceCaps;
if (FAILED(d3d9->GetDeviceCaps(adapter, deviceType, &deviceCaps)))
{
// Can't continue with out device caps
return;
}
D3DDISPLAYMODE currentDisplayMode;
d3d9->GetAdapterDisplayMode(adapter, ¤tDisplayMode);
GLuint maxSamples = 0;
const gl::FormatSet &allFormats = gl::GetAllSizedInternalFormats();
for (gl::FormatSet::const_iterator internalFormat = allFormats.begin(); internalFormat != allFormats.end(); ++internalFormat)
{
gl::TextureCaps textureCaps = GenerateTextureFormatCaps(*internalFormat, d3d9, deviceType, adapter,
currentDisplayMode.Format);
textureCapsMap->insert(*internalFormat, textureCaps);
maxSamples = std::max(maxSamples, textureCaps.getMaxSamples());
if (gl::GetInternalFormatInfo(*internalFormat).compressed)
{
caps->compressedTextureFormats.push_back(*internalFormat);
}
}
// GL core feature limits
caps->maxElementIndex = static_cast<GLint64>(std::numeric_limits<unsigned int>::max());
// 3D textures are unimplemented in D3D9
caps->max3DTextureSize = 1;
// Only one limit in GL, use the minimum dimension
caps->max2DTextureSize = std::min(deviceCaps.MaxTextureWidth, deviceCaps.MaxTextureHeight);
// D3D treats cube maps as a special case of 2D textures
caps->maxCubeMapTextureSize = caps->max2DTextureSize;
// Array textures are not available in D3D9
caps->maxArrayTextureLayers = 1;
// ES3-only feature
caps->maxLODBias = 0.0f;
// No specific limits on render target size, maximum 2D texture size is equivalent
caps->maxRenderbufferSize = caps->max2DTextureSize;
// Draw buffers are not supported in D3D9
caps->maxDrawBuffers = 1;
caps->maxColorAttachments = 1;
// No specific limits on viewport size, maximum 2D texture size is equivalent
caps->maxViewportWidth = caps->max2DTextureSize;
caps->maxViewportHeight = caps->maxViewportWidth;
// Point size is clamped to 1.0f when the shader model is less than 3
caps->minAliasedPointSize = 1.0f;
caps->maxAliasedPointSize = ((D3DSHADER_VERSION_MAJOR(deviceCaps.PixelShaderVersion) >= 3) ? deviceCaps.MaxPointSize : 1.0f);
// Wide lines not supported
caps->minAliasedLineWidth = 1.0f;
caps->maxAliasedLineWidth = 1.0f;
// Primitive count limits (unused in ES2)
caps->maxElementsIndices = 0;
caps->maxElementsVertices = 0;
// Program and shader binary formats (no supported shader binary formats)
caps->programBinaryFormats.push_back(GL_PROGRAM_BINARY_ANGLE);
caps->vertexHighpFloat.setIEEEFloat();
caps->vertexMediumpFloat.setIEEEFloat();
caps->vertexLowpFloat.setIEEEFloat();
caps->fragmentHighpFloat.setIEEEFloat();
caps->fragmentMediumpFloat.setIEEEFloat();
caps->fragmentLowpFloat.setIEEEFloat();
// Some (most) hardware only supports single-precision floating-point numbers,
// which can accurately represent integers up to +/-16777216
caps->vertexHighpInt.setSimulatedInt(24);
caps->vertexMediumpInt.setSimulatedInt(24);
caps->vertexLowpInt.setSimulatedInt(24);
caps->fragmentHighpInt.setSimulatedInt(24);
caps->fragmentMediumpInt.setSimulatedInt(24);
caps->fragmentLowpInt.setSimulatedInt(24);
// WaitSync is ES3-only, set to zero
caps->maxServerWaitTimeout = 0;
// Vertex shader limits
caps->maxVertexAttributes = 16;
const size_t reservedVertexUniformVectors = 2; // dx_ViewAdjust and dx_DepthRange.
const size_t MAX_VERTEX_CONSTANT_VECTORS_D3D9 = 256;
caps->maxVertexUniformVectors = MAX_VERTEX_CONSTANT_VECTORS_D3D9 - reservedVertexUniformVectors;
caps->maxVertexUniformComponents = caps->maxVertexUniformVectors * 4;
caps->maxVertexUniformBlocks = 0;
// SM3 only supports 11 output variables, with a special 12th register for PSIZE.
const size_t MAX_VERTEX_OUTPUT_VECTORS_SM3 = 9;
const size_t MAX_VERTEX_OUTPUT_VECTORS_SM2 = 7;
caps->maxVertexOutputComponents = ((deviceCaps.VertexShaderVersion >= D3DVS_VERSION(3, 0)) ? MAX_VERTEX_OUTPUT_VECTORS_SM3
: MAX_VERTEX_OUTPUT_VECTORS_SM2) * 4;
// Only Direct3D 10 ready devices support all the necessary vertex texture formats.
// We test this using D3D9 by checking support for the R16F format.
if (deviceCaps.VertexShaderVersion >= D3DVS_VERSION(3, 0) &&
SUCCEEDED(d3d9->CheckDeviceFormat(adapter, deviceType, currentDisplayMode.Format,
D3DUSAGE_QUERY_VERTEXTEXTURE, D3DRTYPE_TEXTURE, D3DFMT_R16F)))
{
const size_t MAX_TEXTURE_IMAGE_UNITS_VTF_SM3 = 4;
caps->maxVertexTextureImageUnits = MAX_TEXTURE_IMAGE_UNITS_VTF_SM3;
}
else
{
caps->maxVertexTextureImageUnits = 0;
}
// Fragment shader limits
const size_t reservedPixelUniformVectors = 3; // dx_ViewCoords, dx_DepthFront and dx_DepthRange.
const size_t MAX_PIXEL_CONSTANT_VECTORS_SM3 = 224;
const size_t MAX_PIXEL_CONSTANT_VECTORS_SM2 = 32;
caps->maxFragmentUniformVectors = ((deviceCaps.PixelShaderVersion >= D3DPS_VERSION(3, 0)) ? MAX_PIXEL_CONSTANT_VECTORS_SM3
: MAX_PIXEL_CONSTANT_VECTORS_SM2) - reservedPixelUniformVectors;
caps->maxFragmentUniformComponents = caps->maxFragmentUniformVectors * 4;
caps->maxFragmentUniformBlocks = 0;
caps->maxFragmentInputComponents = caps->maxVertexOutputComponents;
caps->maxTextureImageUnits = 16;
caps->minProgramTexelOffset = 0;
caps->maxProgramTexelOffset = 0;
// Aggregate shader limits (unused in ES2)
caps->maxUniformBufferBindings = 0;
caps->maxUniformBlockSize = 0;
caps->uniformBufferOffsetAlignment = 0;
caps->maxCombinedUniformBlocks = 0;
caps->maxCombinedVertexUniformComponents = 0;
caps->maxCombinedFragmentUniformComponents = 0;
caps->maxVaryingComponents = 0;
// Aggregate shader limits
caps->maxVaryingVectors = caps->maxVertexOutputComponents / 4;
caps->maxCombinedTextureImageUnits = caps->maxVertexTextureImageUnits + caps->maxTextureImageUnits;
// Transform feedback limits
caps->maxTransformFeedbackInterleavedComponents = 0;
caps->maxTransformFeedbackSeparateAttributes = 0;
caps->maxTransformFeedbackSeparateComponents = 0;
// Multisample limits
caps->maxSamples = maxSamples;
// GL extension support
extensions->setTextureExtensionSupport(*textureCapsMap);
extensions->elementIndexUint = deviceCaps.MaxVertexIndex >= (1 << 16);
extensions->getProgramBinary = true;
extensions->rgb8rgba8 = true;
extensions->readFormatBGRA = true;
extensions->pixelBufferObject = false;
extensions->mapBuffer = false;
extensions->mapBufferRange = false;
// textureRG is emulated and not performant.
extensions->textureRG = false;
D3DADAPTER_IDENTIFIER9 adapterId = {};
if (SUCCEEDED(d3d9->GetAdapterIdentifier(adapter, 0, &adapterId)))
{
// ATI cards on XP have problems with non-power-of-two textures.
extensions->textureNPOT = !(deviceCaps.TextureCaps & D3DPTEXTURECAPS_POW2) &&
!(deviceCaps.TextureCaps & D3DPTEXTURECAPS_CUBEMAP_POW2) &&
!(deviceCaps.TextureCaps & D3DPTEXTURECAPS_NONPOW2CONDITIONAL) &&
!(!isWindowsVistaOrGreater() && adapterId.VendorId == VENDOR_ID_AMD);
// Disable depth texture support on AMD cards (See ANGLE issue 839)
if (adapterId.VendorId == VENDOR_ID_AMD)
{
extensions->depthTextures = false;
}
}
else
{
extensions->textureNPOT = false;
}
extensions->drawBuffers = false;
extensions->textureStorage = true;
// Must support a minimum of 2:1 anisotropy for max anisotropy to be considered supported, per the spec
extensions->textureFilterAnisotropic = (deviceCaps.RasterCaps & D3DPRASTERCAPS_ANISOTROPY) != 0 && deviceCaps.MaxAnisotropy >= 2;
extensions->maxTextureAnisotropy = static_cast<GLfloat>(deviceCaps.MaxAnisotropy);
// Check occlusion query support by trying to create one
IDirect3DQuery9 *occlusionQuery = NULL;
extensions->occlusionQueryBoolean = SUCCEEDED(device->CreateQuery(D3DQUERYTYPE_OCCLUSION, &occlusionQuery)) && occlusionQuery;
SafeRelease(occlusionQuery);
// Check event query support by trying to create one
IDirect3DQuery9 *eventQuery = NULL;
extensions->fence = SUCCEEDED(device->CreateQuery(D3DQUERYTYPE_EVENT, &eventQuery)) && eventQuery;
SafeRelease(eventQuery);
extensions->timerQuery = false; // Unimplemented
extensions->robustness = true;
extensions->blendMinMax = true;
extensions->framebufferBlit = true;
extensions->framebufferMultisample = true;
extensions->instancedArrays = deviceCaps.PixelShaderVersion >= D3DPS_VERSION(3, 0);
extensions->packReverseRowOrder = true;
extensions->standardDerivatives = (deviceCaps.PS20Caps.Caps & D3DPS20CAPS_GRADIENTINSTRUCTIONS) != 0;
extensions->shaderTextureLOD = true;
extensions->fragDepth = true;
extensions->textureUsage = true;
extensions->translatedShaderSource = true;
extensions->fboRenderMipmap = false;
extensions->discardFramebuffer = false; // It would be valid to set this to true, since glDiscardFramebufferEXT is just a hint
extensions->colorBufferFloat = false;
extensions->debugMarker = true;
}
bool Display::initialize()
{
if (isInitialized())
{
return true;
}
mD3d9Module = LoadLibrary(TEXT("d3d9.dll"));
if (mD3d9Module == NULL)
{
terminate();
return false;
}
typedef IDirect3D9* (WINAPI *Direct3DCreate9Func)(UINT);
Direct3DCreate9Func Direct3DCreate9Ptr = reinterpret_cast<Direct3DCreate9Func>(GetProcAddress(mD3d9Module, "Direct3DCreate9"));
if (Direct3DCreate9Ptr == NULL)
{
terminate();
return false;
}
typedef HRESULT (WINAPI *Direct3DCreate9ExFunc)(UINT, IDirect3D9Ex**);
Direct3DCreate9ExFunc Direct3DCreate9ExPtr = reinterpret_cast<Direct3DCreate9ExFunc>(GetProcAddress(mD3d9Module, "Direct3DCreate9Ex"));
// Use Direct3D9Ex if available. Among other things, this version is less
// inclined to report a lost context, for example when the user switches
// desktop. Direct3D9Ex is available in Windows Vista and later if suitable drivers are available.
if (Direct3DCreate9ExPtr && SUCCEEDED(Direct3DCreate9ExPtr(D3D_SDK_VERSION, &mD3d9ex)))
{
ASSERT(mD3d9ex);
mD3d9ex->QueryInterface(IID_IDirect3D9, reinterpret_cast<void**>(&mD3d9));
ASSERT(mD3d9);
}
else
{
mD3d9 = Direct3DCreate9Ptr(D3D_SDK_VERSION);
}
if (mD3d9)
{
if (mDc != NULL)
{
// UNIMPLEMENTED(); // FIXME: Determine which adapter index the device context corresponds to
}
HRESULT result = mD3d9->GetDeviceCaps(mAdapter, mDeviceType, &mDeviceCaps);
if (result == D3DERR_OUTOFVIDEOMEMORY || result == E_OUTOFMEMORY)
{
return error(EGL_BAD_ALLOC, false);
}
if (mDeviceCaps.PixelShaderVersion < D3DPS_VERSION(2, 0))
{
terminate();
return error(EGL_NOT_INITIALIZED, false);
}
mMinSwapInterval = 4;
mMaxSwapInterval = 0;
if (mDeviceCaps.PresentationIntervals & D3DPRESENT_INTERVAL_IMMEDIATE) {
mMinSwapInterval = std::min(mMinSwapInterval, 0);
mMaxSwapInterval = std::max(mMaxSwapInterval, 0);
}
if (mDeviceCaps.PresentationIntervals & D3DPRESENT_INTERVAL_ONE) {
mMinSwapInterval = std::min(mMinSwapInterval, 1);
mMaxSwapInterval = std::max(mMaxSwapInterval, 1);
}
if (mDeviceCaps.PresentationIntervals & D3DPRESENT_INTERVAL_TWO) {
mMinSwapInterval = std::min(mMinSwapInterval, 2);
mMaxSwapInterval = std::max(mMaxSwapInterval, 2);
}
if (mDeviceCaps.PresentationIntervals & D3DPRESENT_INTERVAL_THREE) {
mMinSwapInterval = std::min(mMinSwapInterval, 3);
mMaxSwapInterval = std::max(mMaxSwapInterval, 3);
}
if (mDeviceCaps.PresentationIntervals & D3DPRESENT_INTERVAL_FOUR) {
mMinSwapInterval = std::min(mMinSwapInterval, 4);
mMaxSwapInterval = std::max(mMaxSwapInterval, 4);
}
const D3DFORMAT renderTargetFormats[] =
{
D3DFMT_A1R5G5B5,
// D3DFMT_A2R10G10B10, // The color_ramp conformance test uses ReadPixels with UNSIGNED_BYTE causing it to think that rendering skipped a colour value.
D3DFMT_A8R8G8B8,
D3DFMT_R5G6B5,
D3DFMT_X1R5G5B5,
D3DFMT_X8R8G8B8
};
const D3DFORMAT depthStencilFormats[] =
{
// D3DFMT_D16_LOCKABLE,
D3DFMT_D32,
// D3DFMT_D15S1,
D3DFMT_D24S8,
D3DFMT_D24X8,
// D3DFMT_D24X4S4,
D3DFMT_D16,
// D3DFMT_D32F_LOCKABLE,
// D3DFMT_D24FS8
};
D3DDISPLAYMODE currentDisplayMode;
mD3d9->GetAdapterDisplayMode(mAdapter, ¤tDisplayMode);
ConfigSet configSet;
for (int formatIndex = 0; formatIndex < sizeof(renderTargetFormats) / sizeof(D3DFORMAT); formatIndex++)
{
D3DFORMAT renderTargetFormat = renderTargetFormats[formatIndex];
HRESULT result = mD3d9->CheckDeviceFormat(mAdapter, mDeviceType, currentDisplayMode.Format, D3DUSAGE_RENDERTARGET, D3DRTYPE_SURFACE, renderTargetFormat);
if (SUCCEEDED(result))
{
for (int depthStencilIndex = 0; depthStencilIndex < sizeof(depthStencilFormats) / sizeof(D3DFORMAT); depthStencilIndex++)
{
D3DFORMAT depthStencilFormat = depthStencilFormats[depthStencilIndex];
HRESULT result = mD3d9->CheckDeviceFormat(mAdapter, mDeviceType, currentDisplayMode.Format, D3DUSAGE_DEPTHSTENCIL, D3DRTYPE_SURFACE, depthStencilFormat);
if (SUCCEEDED(result))
{
HRESULT result = mD3d9->CheckDepthStencilMatch(mAdapter, mDeviceType, currentDisplayMode.Format, renderTargetFormat, depthStencilFormat);
if (SUCCEEDED(result))
{
// FIXME: enumerate multi-sampling
configSet.add(currentDisplayMode, mMinSwapInterval, mMaxSwapInterval, renderTargetFormat, depthStencilFormat, 0);
}
}
}
}
}
// Give the sorted configs a unique ID and store them internally
EGLint index = 1;
for (ConfigSet::Iterator config = configSet.mSet.begin(); config != configSet.mSet.end(); config++)
{
Config configuration = *config;
configuration.mConfigID = index;
index++;
mConfigSet.mSet.insert(configuration);
}
if (!createDevice())
{
terminate();
return false;
}
}
if (!isInitialized())
{
terminate();
return false;
}
return true;
}
