static HRESULT WINAPI IDirect3D8Impl_GetDeviceCaps(LPDIRECT3D8 iface, UINT Adapter, D3DDEVTYPE DeviceType, D3DCAPS8* pCaps) {
IDirect3D8Impl *This = (IDirect3D8Impl *)iface;
HRESULT hrc = D3D_OK;
WINED3DCAPS *pWineCaps;
TRACE("(%p) Relay %d %u %p\n", This, Adapter, DeviceType, pCaps);
if(NULL == pCaps){
return D3DERR_INVALIDCALL;
}
pWineCaps = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(WINED3DCAPS));
if(pWineCaps == NULL){
return D3DERR_INVALIDCALL; /*well this is what MSDN says to return*/
}
EnterCriticalSection(&d3d8_cs);
hrc = IWineD3D_GetDeviceCaps(This->WineD3D, Adapter, DeviceType, pWineCaps);
LeaveCriticalSection(&d3d8_cs);
WINECAPSTOD3D8CAPS(pCaps, pWineCaps)
HeapFree(GetProcessHeap(), 0, pWineCaps);
/* D3D8 doesn't support SM 2.0 or higher, so clamp to 1.x */
if(pCaps->PixelShaderVersion > D3DPS_VERSION(1,4)){
pCaps->PixelShaderVersion = D3DPS_VERSION(1,4);
}
if(pCaps->VertexShaderVersion > D3DVS_VERSION(1,1)){
pCaps->VertexShaderVersion = D3DVS_VERSION(1,1);
}
TRACE("(%p) returning %p\n", This, pCaps);
return hrc;
}
void fixup_caps(WINED3DCAPS *caps)
{
/* D3D8 doesn't support SM 2.0 or higher, so clamp to 1.x */
if (caps->PixelShaderVersion > D3DPS_VERSION(1,4)) {
caps->PixelShaderVersion = D3DPS_VERSION(1,4);
}
if (caps->VertexShaderVersion > D3DVS_VERSION(1,1)) {
caps->VertexShaderVersion = D3DVS_VERSION(1,1);
}
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 CD3DSkelMesh::Reset()
{
m_VBController.Reset();
m_iMaxBonesPerVert = 0;
m_iMaxBonesPerTri = 0;
m_iVertCount = 0;
m_iPolyCount = 0;
m_eRenderMethod = eD3DRenderDirect;
m_iBoneSetCount = 0;
m_pBoneSetArray = NULL;
m_VertType = eNO_WORLD_BLENDS;
m_bSWVertProcessing = ((g_Device.GetDeviceCaps()->DevCaps & D3DDEVCAPS_HWTRANSFORMANDLIGHT) == 0) ? true : false;
m_bSWVSBuffers = false;
// Use software processing for shaders ?
if ( g_Device.GetDeviceCaps()->VertexShaderVersion < D3DVS_VERSION(1,1) )
m_bSWVSBuffers = true;
// in case software has been forced
if ( g_CV_ForceSWVertProcess )
m_bSWVertProcessing = true;
m_pIndexData = NULL;
m_bNonFixPipeData = false;
m_bReIndexedBones = false;
m_pReIndexedBoneList= NULL;
for (uint32 i = 0; i < 4; ++i)
m_pVertData[i] = NULL;
}
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;
}
//-------------------------------------------------------------
// 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 CD3DVAMesh::Reset()
{
m_VBController.Reset();
m_iMaxBonesPerVert = 0;
m_iMaxBonesPerTri = 0;
m_iVertCount = 0;
m_iUnDupVertCount = 0;
m_iPolyCount = 0;
m_iBoneEffector = 0;
m_iAnimNodeIdx = 0;
m_iDupMapListCount = 0;
m_pDupMapList = NULL;
m_pIndexData = NULL;
m_bSWVertProcessing = ((g_Device.GetDeviceCaps()->DevCaps & D3DDEVCAPS_HWTRANSFORMANDLIGHT) == 0) ? true : false;
m_bSWVSBuffers = false;
// Use software processing for shaders ?
if ( g_Device.GetDeviceCaps()->VertexShaderVersion < D3DVS_VERSION(1,1) )
m_bSWVSBuffers = true;
// in case software has been forced
if ( g_CV_ForceSWVertProcess )
m_bSWVertProcessing = true;
m_bNonFixPipeData = false;
for (uint32 i = 0; i < 4; ++i) m_pVertData[i] = NULL;
}
HRESULT BUMPMAP::Load()
{
D3DCAPS9 caps;
m_spD3DDevice->GetDeviceCaps( &caps );
if( caps.VertexShaderVersion >= D3DVS_VERSION( 1, 1 ) && caps.PixelShaderVersion >= D3DPS_VERSION( 2, 0 ) )
{
LPD3DXBUFFER pErr = NULL;
HRESULT hr = D3DXCreateEffectFromFile( m_spD3DDevice, "BumpMap.fx", NULL, NULL, 0, NULL, &m_pEffect, &pErr );
if( SUCCEEDED( hr ) )
{
m_pTechnique = m_pEffect->GetTechniqueByName( "TShader" );
m_pWVP = m_pEffect->GetParameterByName( NULL, "m_WVP" );
m_pLightDir = m_pEffect->GetParameterByName( NULL, "m_LightDir" );
m_pEyePos = m_pEffect->GetParameterByName( NULL, "m_EyePos" );
m_pAmbient = m_pEffect->GetParameterByName( NULL, "m_Ambient" );
m_pSpecularPower = m_pEffect->GetParameterByName( NULL, "m_SpecularPower" );
m_pSpecular = m_pEffect->GetParameterByName( NULL, "m_Specular" );
m_pEffect->SetTechnique( m_pTechnique );
}
else
{
return -1;
}
}
else
{
return -2;
}
return S_OK;
}
LRESULT InitD3D(HWND hWnd)
{
if( NULL == ( g_pD3D = Direct3DCreate9( D3D_SDK_VERSION ) ) )
return E_FAIL;
D3DDISPLAYMODE d3ddm;
if( FAILED( g_pD3D->GetAdapterDisplayMode( D3DADAPTER_DEFAULT, &d3ddm ) ) )
return E_FAIL;
D3DPRESENT_PARAMETERS d3dpp;
ZeroMemory( &d3dpp, sizeof(d3dpp) );
d3dpp.Windowed = TRUE;
d3dpp.BackBufferCount = 2;
d3dpp.MultiSampleType = D3DMULTISAMPLE_NONE;
d3dpp.MultiSampleQuality =0;
d3dpp.SwapEffect = D3DSWAPEFFECT_FLIP;
d3dpp.BackBufferFormat = d3ddm.Format;
d3dpp.EnableAutoDepthStencil = TRUE;
d3dpp.AutoDepthStencilFormat = D3DFMT_D16;
d3dpp.Flags = D3DPRESENTFLAG_DISCARD_DEPTHSTENCIL;
d3dpp.PresentationInterval = D3DPRESENT_INTERVAL_IMMEDIATE;
if(theViewer.getFullscreen())
{
d3dpp.Windowed = FALSE;
d3dpp.BackBufferWidth=theViewer.getWidth();
d3dpp.BackBufferHeight=theViewer.getHeight();
}
D3DCAPS9 Caps;
g_pD3D->GetDeviceCaps(D3DADAPTER_DEFAULT,D3DDEVTYPE_HAL,&Caps);
if((Caps.TextureOpCaps & D3DTEXOPCAPS_DOTPRODUCT3) == 0)
{
MessageBox(hWnd,
"Your 3D Card don't support DOT3 operation, bumpmapping is disabled",
"Warning",MB_OK);
g_bCanDot3=false;
}
if(Caps.VertexShaderVersion >= D3DVS_VERSION(1,1))
{
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_HAL, hWnd,
D3DCREATE_SOFTWARE_VERTEXPROCESSING,
&d3dpp, &g_pD3DDevice ) ) )
return E_FAIL;
}
return S_OK;
}
//=============================================================================================================
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();
}
Dx9BackEnd::Dx9BackEnd(Context *context, IDirect3DDevice9 *d3ddevice)
: mDevice(d3ddevice)
{
mDevice->AddRef();
for (int i = 0; i < MAX_VERTEX_ATTRIBS; ++i)
{
mAppliedAttribEnabled[i] = true;
mStreamFrequency[i] = STREAM_FREQUENCY_UNINSTANCED;
}
mStreamFrequency[MAX_VERTEX_ATTRIBS] = STREAM_FREQUENCY_UNINSTANCED;
D3DCAPS9 caps = context->getDeviceCaps();
IDirect3D9 *d3dObject;
mDevice->GetDirect3D(&d3dObject);
D3DADAPTER_IDENTIFIER9 ident;
d3dObject->GetAdapterIdentifier(caps.AdapterOrdinal, 0, &ident);
d3dObject->Release();
// Instancing is mandatory for all HW with SM3 vertex shaders, but avoid hardware where it does not work.
mUseInstancingForStrideZero = (caps.VertexShaderVersion >= D3DVS_VERSION(3, 0) && ident.VendorId != 0x8086);
mSupportIntIndices = (caps.MaxVertexIndex >= (1 << 16));
checkVertexCaps(caps.DeclTypes);
}
void Graphics::initialize(HWND hw, int w, int h, bool full)
{
hwnd = hw;
width = w;
height = h;
fullscreen = full;
direct3d = Direct3DCreate9(D3D_SDK_VERSION);
if (direct3d == NULL)
throw(GameError(gameErrorNS::FATAL_ERROR, "Error initializing Direct3D"));
initD3Dpp();
if(fullscreen)
{
if(isAdapterCompatible())
d3dpp.FullScreen_RefreshRateInHz = pMode.RefreshRate;
else
throw(GameError(gameErrorNS::FATAL_ERROR,
"The graphics device does not support the specified resolution and/or format."));
}
D3DCAPS9 caps;
DWORD behavior;
result = direct3d->GetDeviceCaps(D3DADAPTER_DEFAULT, D3DDEVTYPE_HAL, &caps);
if( (caps.DevCaps & D3DDEVCAPS_HWTRANSFORMANDLIGHT) == 0 ||
caps.VertexShaderVersion < D3DVS_VERSION(1,1) )
behavior = D3DCREATE_SOFTWARE_VERTEXPROCESSING;
else
behavior = D3DCREATE_HARDWARE_VERTEXPROCESSING;
result = direct3d->CreateDevice(
D3DADAPTER_DEFAULT,
D3DDEVTYPE_HAL,
hwnd,
behavior,
&d3dpp,
&device3d);
if (FAILED(result))
throw(GameError(gameErrorNS::FATAL_ERROR, "Error creating Direct3D device"));
result = D3DXCreateSprite(device3d, &sprite);
if (FAILED(result))
throw(GameError(gameErrorNS::FATAL_ERROR, "Error creating Direct3D sprite"));
device3d->SetRenderState(D3DRS_BLENDOP, D3DBLENDOP_ADD);
device3d->SetRenderState(D3DRS_SRCBLEND, D3DBLEND_SRCALPHA);
device3d->SetRenderState(D3DRS_DESTBLEND, D3DBLEND_INVSRCALPHA);
if( FAILED( direct3d->CheckDeviceFormat(caps.AdapterOrdinal,
caps.DeviceType,
d3dpp.BackBufferFormat,
D3DUSAGE_DEPTHSTENCIL,
D3DRTYPE_SURFACE,
D3DFMT_D24S8 ) ) )
stencilSupport = false;
else
stencilSupport = true;
device3d->CreateQuery(D3DQUERYTYPE_OCCLUSION, &pOcclusionQuery);
}
HRESULT RacorX5::ConfirmDevice(D3DCAPS8* pCaps, DWORD dwBehavior, D3DFORMAT Format)
{
if ((dwBehavior & D3DCREATE_HARDWARE_VERTEXPROCESSING) || (D3DCREATE_MIXED_VERTEXPROCESSING))
{
if (pCaps->VertexShaderVersion < D3DVS_VERSION(1, 1))
return E_FAIL;
}
return S_OK;
}
//=============================================================================
// Initialize DirectX graphics
// throws GameError on error
//=============================================================================
void Graphics::initialize(HWND hw, int w, int h, bool full)
{
hwnd = hw;
width = w;
height = h;
fullscreen = full;
//initialize Direct3D
direct3d = Direct3DCreate9(D3D_SDK_VERSION);
if (direct3d == NULL)
throw(GameError(gameErrorNS::FATAL_ERROR, "Error initializing Direct3D"));
initD3Dpp(); // init D3D presentation parameters
if(fullscreen) // if full-screen mode
{
if(isAdapterCompatible()) // is the adapter compatible
// set the refresh rate with a compatible one
d3dpp.FullScreen_RefreshRateInHz = pMode.RefreshRate;
else
throw(GameError(gameErrorNS::FATAL_ERROR,
"The graphics device does not support the specified resolution and/or format."));
}
// determine if graphics card supports harware texturing and lighting and vertex shaders
D3DCAPS9 caps;
DWORD behavior;
result = direct3d->GetDeviceCaps(D3DADAPTER_DEFAULT, D3DDEVTYPE_HAL, &caps);
// If device doesn't support HW T&L or doesn't support 1.1 vertex
// shaders in hardware, then switch to software vertex processing.
if( (caps.DevCaps & D3DDEVCAPS_HWTRANSFORMANDLIGHT) == 0 ||
caps.VertexShaderVersion < D3DVS_VERSION(1,1) )
behavior = D3DCREATE_SOFTWARE_VERTEXPROCESSING; // use software only processing
else
behavior = D3DCREATE_HARDWARE_VERTEXPROCESSING; // use hardware only processing
//create Direct3D device
result = direct3d->CreateDevice(
D3DADAPTER_DEFAULT,
D3DDEVTYPE_HAL,
hwnd,
behavior,
&d3dpp,
&device3d);
if (FAILED(result))
throw(GameError(gameErrorNS::FATAL_ERROR, "Error creating Direct3D device"));
result = D3DXCreateSprite(device3d, &sprite);
if (FAILED(result))
throw(GameError(gameErrorNS::FATAL_ERROR, "Error creating Direct3D sprite"));
// Configure for alpha blend of primitives
device3d->SetRenderState(D3DRS_BLENDOP, D3DBLENDOP_ADD);
device3d->SetRenderState(D3DRS_SRCBLEND, D3DBLEND_SRCALPHA);
device3d->SetRenderState(D3DRS_DESTBLEND, D3DBLEND_INVSRCALPHA);
}
//--------------------------------------------------------------------------------------
// This callback function is called immediately before a device is created to allow the
// application to modify the device settings. The supplied pDeviceSettings parameter
// contains the settings that the framework has selected for the new device, and the
// application can make any desired changes directly to this structure. Note however that
// DXUT will not correct invalid device settings so care must be taken
// to return valid device settings, otherwise IDirect3D9::CreateDevice() will fail.
//--------------------------------------------------------------------------------------
bool CALLBACK ModifyDeviceSettings( DXUTDeviceSettings* pDeviceSettings, void* pUserContext )
{
assert( DXUT_D3D9_DEVICE == pDeviceSettings->ver );
HRESULT hr;
IDirect3D9* pD3D = DXUTGetD3D9Object();
D3DCAPS9 caps;
V( pD3D->GetDeviceCaps( pDeviceSettings->d3d9.AdapterOrdinal,
pDeviceSettings->d3d9.DeviceType,
&caps ) );
// If device doesn't support HW T&L or doesn't support 1.1 vertex shaders in HW
// then switch to SWVP.
if( ( caps.DevCaps & D3DDEVCAPS_HWTRANSFORMANDLIGHT ) == 0 ||
caps.VertexShaderVersion < D3DVS_VERSION( 1, 1 ) )
{
pDeviceSettings->d3d9.BehaviorFlags = D3DCREATE_SOFTWARE_VERTEXPROCESSING;
}
// Debugging vertex shaders requires either REF or software vertex processing
// and debugging pixel shaders requires REF.
#ifdef DEBUG_VS
if( pDeviceSettings->d3d9.DeviceType != D3DDEVTYPE_REF )
{
pDeviceSettings->d3d9.BehaviorFlags &= ~D3DCREATE_HARDWARE_VERTEXPROCESSING;
pDeviceSettings->d3d9.BehaviorFlags &= ~D3DCREATE_PUREDEVICE;
pDeviceSettings->d3d9.BehaviorFlags |= D3DCREATE_SOFTWARE_VERTEXPROCESSING;
}
#endif
#ifdef DEBUG_PS
pDeviceSettings->d3d9.DeviceType = D3DDEVTYPE_REF;
#endif
// Enable anti-aliasing for HAL devices which support it
CD3D9Enumeration* pEnum = DXUTGetD3D9Enumeration();
CD3D9EnumDeviceSettingsCombo* pCombo = pEnum->GetDeviceSettingsCombo( &pDeviceSettings->d3d9 );
if( pDeviceSettings->d3d9.DeviceType == D3DDEVTYPE_HAL &&
pCombo->multiSampleTypeList.Contains( D3DMULTISAMPLE_4_SAMPLES ) )
{
pDeviceSettings->d3d9.pp.MultiSampleType = D3DMULTISAMPLE_4_SAMPLES;
pDeviceSettings->d3d9.pp.MultiSampleQuality = 0;
}
// For the first device created if its a REF device, optionally display a warning dialog box
static bool s_bFirstTime = true;
if( s_bFirstTime )
{
s_bFirstTime = false;
if( pDeviceSettings->d3d9.DeviceType == D3DDEVTYPE_REF )
DXUTDisplaySwitchingToREFWarning( pDeviceSettings->ver );
}
return true;
}
int D3D9DeviceCaps::VertexShaderVersion()
{
switch (mCaps.VertexShaderVersion)
{
case D3DVS_VERSION(3, 0):
return (int)SP_VS;
default:
return 0;
}
}
//-----------------------------------------------------------------------------
// Name: ConfirmDevice()
// Desc: Called during device intialization, this code checks the device
// for some minimum set of capabilities
//-----------------------------------------------------------------------------
HRESULT CMyD3DApplication::ConfirmDevice( D3DCAPS8* pCaps, DWORD dwBehavior,
D3DFORMAT Format )
{
if( !(dwBehavior & D3DCREATE_SOFTWARE_VERTEXPROCESSING) &&
!(pCaps->VertexShaderVersion >= D3DVS_VERSION(1, 0)) )
{
return E_FAIL;
}
return S_OK;
}
//--------------------------------------------------------------------------------------
// This callback function is called immediately before a device is created to allow the
// application to modify the device settings. The supplied pDeviceSettings parameter
// contains the settings that the framework has selected for the new device, and the
// application can make any desired changes directly to this structure. Note however that
// DXUT will not correct invalid device settings so care must be taken
// to return valid device settings, otherwise IDirect3D9::CreateDevice() will fail.
//--------------------------------------------------------------------------------------
bool CALLBACK ModifyDeviceSettings( DXUTDeviceSettings* pDeviceSettings, void* pUserContext )
{
assert( DXUT_D3D9_DEVICE == pDeviceSettings->ver );
HRESULT hr;
IDirect3D9* pD3D = DXUTGetD3D9Object();
D3DCAPS9 caps;
V( pD3D->GetDeviceCaps( pDeviceSettings->d3d9.AdapterOrdinal,
pDeviceSettings->d3d9.DeviceType,
&caps ) );
// Turn vsync off
pDeviceSettings->d3d9.pp.PresentationInterval = D3DPRESENT_INTERVAL_IMMEDIATE;
g_SettingsDlg.GetDialogControl()->GetComboBox( DXUTSETTINGSDLG_PRESENT_INTERVAL )->SetEnabled( false );
// If device doesn't support HW T&L or doesn't support 2.0 vertex shaders in HW
// then switch to SWVP.
if( ( caps.DevCaps & D3DDEVCAPS_HWTRANSFORMANDLIGHT ) == 0 ||
caps.VertexShaderVersion < D3DVS_VERSION( 2, 0 ) )
{
pDeviceSettings->d3d9.BehaviorFlags = D3DCREATE_SOFTWARE_VERTEXPROCESSING;
}
// Debugging vertex shaders requires either REF or software vertex processing
// and debugging pixel shaders requires REF.
#ifdef DEBUG_VS
if( pDeviceSettings->d3d9.DeviceType != D3DDEVTYPE_REF )
{
pDeviceSettings->d3d9.BehaviorFlags &= ~D3DCREATE_HARDWARE_VERTEXPROCESSING;
pDeviceSettings->d3d9.BehaviorFlags &= ~D3DCREATE_PUREDEVICE;
pDeviceSettings->d3d9.BehaviorFlags |= D3DCREATE_SOFTWARE_VERTEXPROCESSING;
}
#endif
#ifdef DEBUG_PS
pDeviceSettings->d3d9.DeviceType = D3DDEVTYPE_REF;
#endif
if( caps.MaxVertexBlendMatrices < 2 )
pDeviceSettings->d3d9.BehaviorFlags = D3DCREATE_SOFTWARE_VERTEXPROCESSING;
// For the first device created if its a REF device, optionally display a warning dialog box
static bool s_bFirstTime = true;
if( s_bFirstTime )
{
s_bFirstTime = false;
if( pDeviceSettings->d3d9.DeviceType == D3DDEVTYPE_REF )
DXUTDisplaySwitchingToREFWarning( pDeviceSettings->ver );
}
return true;
}
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;
}
bool CALLBACK ModifyDeviceSettings(DXUTDeviceSettings* pDeviceSettings, void* pUserContext)
{
IDirect3D9* pD3D = DXUTGetD3D9Object();
D3DCAPS9 caps;
HRESULT hr;
V(pD3D->GetDeviceCaps(pDeviceSettings->d3d9.AdapterOrdinal, pDeviceSettings->d3d9.DeviceType, &caps));
if((caps.DevCaps & D3DDEVCAPS_HWTRANSFORMANDLIGHT) == 0 ||
caps.VertexShaderVersion < D3DVS_VERSION(1, 1))
{
pDeviceSettings->d3d9.BehaviorFlags = D3DCREATE_SOFTWARE_VERTEXPROCESSING;
}
else
{
pDeviceSettings->d3d9.BehaviorFlags = D3DCREATE_HARDWARE_VERTEXPROCESSING;
}
// This application is designed to work on a pure device by not using
// IDirect3D9::Get*() methods, so create a pure device if supported and using HWVP.
if((caps.DevCaps & D3DDEVCAPS_PUREDEVICE) != 0 &&
(pDeviceSettings->d3d9.BehaviorFlags & D3DCREATE_HARDWARE_VERTEXPROCESSING) != 0)
pDeviceSettings->d3d9.BehaviorFlags |= D3DCREATE_PUREDEVICE;
// Debugging vertex shaders requires either REF or software vertex processing
// and debugging pixel shaders requires REF.
#ifdef DEBUG_VS
if(pDeviceSettings->d3d9.DeviceType != D3DDEVTYPE_REF)
{
pDeviceSettings->d3d9.BehaviorFlags &= ~D3DCREATE_HARDWARE_VERTEXPROCESSING;
pDeviceSettings->d3d9.BehaviorFlags &= ~D3DCREATE_PUREDEVICE;
pDeviceSettings->d3d9.BehaviorFlags |= D3DCREATE_SOFTWARE_VERTEXPROCESSING;
}
#endif
#ifdef DEBUG_PS
pDeviceSettings->d3d9.DeviceType = D3DDEVTYPE_REF;
#endif
// Enable anti-aliasing for HAL devices which support it
CD3D9Enumeration* pEnum = DXUTGetD3D9Enumeration();
CD3D9EnumDeviceSettingsCombo* pCombo = pEnum->GetDeviceSettingsCombo(&pDeviceSettings->d3d9);
if(pDeviceSettings->d3d9.DeviceType == D3DDEVTYPE_HAL &&
pCombo->multiSampleTypeList.Contains(D3DMULTISAMPLE_4_SAMPLES))
{
pDeviceSettings->d3d9.pp.MultiSampleType = D3DMULTISAMPLE_4_SAMPLES;
pDeviceSettings->d3d9.pp.MultiSampleQuality = 0;
}
return true;
}
int32 CRenderLib::m_CreateDevice(int32 type)
{
HRESULT hr;
p_D3D = Direct3DCreate8(D3D_SDK_VERSION);
if (type==HARDWARE_DEVICE) p_DeviceType=D3DDEVTYPE_HAL;
else
if (type==SOFTWARE_DEVICE) p_DeviceType=D3DDEVTYPE_REF;
hr=p_D3D->GetDeviceCaps(D3DADAPTER_DEFAULT, p_DeviceType, &p_DeviceInfo.Caps);
if (hr != D3D_OK) return(0);
// ---------- il device puo' disegnare in finestra ------------
if (p_DeviceInfo.Caps.Caps2 & D3DCAPS2_CANRENDERWINDOWED)
p_DeviceInfo.CanDoWindowed=TRUE;
else p_DeviceInfo.CanDoWindowed=FALSE;
if (type==SOFTWARE_DEVICE)
{
p_DeviceInfo.Behavior=D3DCREATE_SOFTWARE_VERTEXPROCESSING;
p_VSHardwareSupport=0;
}
else
{
// ----------- T&L e capacità di processo dei vertici -----------
if (p_DeviceInfo.Caps.DevCaps & D3DDEVCAPS_HWTRANSFORMANDLIGHT)
{
if (p_DeviceInfo.Caps.VertexShaderVersion >= D3DVS_VERSION(1, 1))
{
// if (p_DeviceInfo.Caps.DevCaps & D3DDEVCAPS_PUREDEVICE)
p_DeviceInfo.Behavior=D3DCREATE_HARDWARE_VERTEXPROCESSING;
//| D3DCREATE_PUREDEVICE;
p_VSHardwareSupport=(1<<16) | (1);
}
else
{
p_DeviceInfo.Behavior=D3DCREATE_MIXED_VERTEXPROCESSING;
p_VSHardwareSupport=0;
}
}
else
{
p_DeviceInfo.Behavior=D3DCREATE_SOFTWARE_VERTEXPROCESSING;
p_VSHardwareSupport=0;
}
}
p_IsDeviceCreated=1;
return(1);
}
//--------------------------------------------------------------------------------------
// Called right before creating a D3D9 or D3D10 device, allowing the app to modify the device settings as needed
//--------------------------------------------------------------------------------------
bool RenderWin32DX9Imp::ModifyDeviceSettings( DXUTDeviceSettings* pDeviceSettings, void* pUserContext )
{
RenderWin32DX9Imp * const render = (RenderWin32DX9Imp*) pUserContext;
if( pDeviceSettings->ver == DXUT_D3D9_DEVICE )
{
IDirect3D9* pD3D = DXUTGetD3D9Object();
D3DCAPS9 Caps;
pD3D->GetDeviceCaps( pDeviceSettings->d3d9.AdapterOrdinal, pDeviceSettings->d3d9.DeviceType, &Caps );
// If device doesn't support HW T&L or doesn't support 1.1 vertex shaders in HW
// then switch to SWVP.
if( ( Caps.DevCaps & D3DDEVCAPS_HWTRANSFORMANDLIGHT ) == 0 ||
Caps.VertexShaderVersion < D3DVS_VERSION( 1, 1 ) )
{
pDeviceSettings->d3d9.BehaviorFlags = D3DCREATE_SOFTWARE_VERTEXPROCESSING;
}
if( render->isBackbufferLockable() )
pDeviceSettings->d3d9.pp.Flags |= D3DPRESENTFLAG_LOCKABLE_BACKBUFFER;
#ifdef DEBUG_VS
// Debugging vertex shaders requires either REF or software vertex processing
// and debugging pixel shaders requires REF.
if( pDeviceSettings->d3d9.DeviceType != D3DDEVTYPE_REF )
{
pDeviceSettings->d3d9.BehaviorFlags &= ~D3DCREATE_HARDWARE_VERTEXPROCESSING;
pDeviceSettings->d3d9.BehaviorFlags &= ~D3DCREATE_PUREDEVICE;
pDeviceSettings->d3d9.BehaviorFlags |= D3DCREATE_SOFTWARE_VERTEXPROCESSING;
}
#endif
#ifdef DEBUG_PS
pDeviceSettings->d3d9.DeviceType = D3DDEVTYPE_REF;
#endif
}
// For the first device created if its a REF device, optionally display a warning dialog box
static bool s_bFirstTime = false; // true;
if( s_bFirstTime )
{
s_bFirstTime = false;
if( ( DXUT_D3D9_DEVICE == pDeviceSettings->ver && pDeviceSettings->d3d9.DeviceType == D3DDEVTYPE_REF ) ||
( DXUT_D3D10_DEVICE == pDeviceSettings->ver &&
pDeviceSettings->d3d10.DriverType == D3D10_DRIVER_TYPE_REFERENCE ) )
DXUTDisplaySwitchingToREFWarning( pDeviceSettings->ver );
}
return true;
}
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;
}
//-------------------------------------------------------------
// Name: ConfirmDevice()
// Desc: 초기화시 호출됨. 필요한 능력(caps)체크
//-------------------------------------------------------------
HRESULT CMyD3DApplication::ConfirmDevice( D3DCAPS9* pCaps,
DWORD dwBehavior, D3DFORMAT Format )
{
UNREFERENCED_PARAMETER( Format );
UNREFERENCED_PARAMETER( dwBehavior );
UNREFERENCED_PARAMETER( pCaps );
// 정점셰이더 버전이 맞지않으면 소프트웨어 처리
if( pCaps->VertexShaderVersion < D3DVS_VERSION(1,1)
&& 0==(dwBehavior & D3DCREATE_SOFTWARE_VERTEXPROCESSING) )
return E_FAIL;
return S_OK;
}
//-------------------------------------------------------------
// 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;
}
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;
}
HRESULT ZFXD3DEnum::ConfirmDevice(D3DCAPS9* pCaps, DWORD dwBehavior,
D3DFORMAT fmtBackbuffer) {
if ( (dwBehavior & D3DCREATE_HARDWARE_VERTEXPROCESSING) ||
(dwBehavior & D3DCREATE_MIXED_VERTEXPROCESSING) ) {
// alphablending from texture pixels supported
if ( !(pCaps->TextureCaps & D3DPTEXTURECAPS_ALPHA) ) {
fprintf(m_pLog, "[ZFXD3D_ENUM] error: no alphablending from texture \n");
return ZFX_FAIL;
}
if (pCaps->VertexShaderVersion < D3DVS_VERSION(1,0) ) {
fprintf(m_pLog, "[ZFXD3D_ENUM] error: Vertex Shader Version < 1.0 \n");
return ZFX_FAIL;
}
}
return ZFX_OK;
} // ConfirmDevice
HRESULT CDirectXDevice::Initialize(const HWND in_hwnd,const BOOL in_windowmode,
const int in_wWidth,const int in_wHeight)
{
m_hwnd =in_hwnd;
D3DCAPS9 caps;
DWORD dwFlag;
D3DDEVTYPE DeviceType = D3DDEVTYPE_HAL;
D3DPRESENT_PARAMETERS d3dpp;
D3DDISPLAYMODE disp;
ZeroMemory(&d3dpp,sizeof(D3DPRESENT_PARAMETERS));
if( NULL == ( m_pd3d9 = Direct3DCreate9( D3D_SDK_VERSION ) ) )
return E_FAIL;
m_pd3d9->GetDeviceCaps(D3DADAPTER_DEFAULT,D3DDEVTYPE_HAL,&caps);//ﾌﾟﾗｲﾏﾘのﾃﾞｨｽﾌﾟﾚｲｱﾀﾞﾌﾟﾀ(=ｸﾞﾗﾎﾞ)の能力取得
m_pd3d9->GetAdapterDisplayMode(D3DADAPTER_DEFAULT,&disp);
if(caps.VertexShaderVersion < D3DVS_VERSION(1,1)) //頂点ｼｪｰﾀﾞのﾊﾞｰｼﾞｮﾝ確認
dwFlag = D3DCREATE_SOFTWARE_VERTEXPROCESSING; //1.1未満なのでｿﾌﾄｳｪｱ処理
else
dwFlag = D3DCREATE_HARDWARE_VERTEXPROCESSING; //1.1以上なのでﾊｰﾄﾞｳｪｱ処理
if(caps.MaxStreams < 3)
{
MessageBox(in_hwnd,TEXT("頂点ストリーム数が足りません"),TEXT("D3D初期化エラー"),NULL);
return E_FAIL;
}
d3dpp.Windowed = in_windowmode;//ｳｲﾝﾄﾞｳﾓｰﾄﾞの指定
d3dpp.SwapEffect = D3DSWAPEFFECT_DISCARD;
d3dpp.hDeviceWindow = in_hwnd;
if(!d3dpp.Windowed) //ﾊﾞｯｸﾊﾞｯﾌｧの設定用にフルスクリーンかどうかを判定
d3dpp.BackBufferFormat = disp.Format;
else
d3dpp.BackBufferFormat = D3DFMT_UNKNOWN; //現在の画面モードを利用
//Z バッファの自動作成
d3dpp.EnableAutoDepthStencil = 1;
d3dpp.AutoDepthStencilFormat = D3DFMT_D24S8;
d3dpp.BackBufferHeight = in_wHeight;
d3dpp.BackBufferWidth = in_wWidth;
d3dpp.PresentationInterval=D3DPRESENT_INTERVAL_DEFAULT;
m_d3dpp = d3dpp;
m_pd3d9->CreateDevice(D3DADAPTER_DEFAULT,DeviceType,in_hwnd,dwFlag|D3DCREATE_MULTITHREADED,&m_d3dpp,&m_pd3ddev);
// m_pd3ddev->Clear(0,0,D3DCLEAR_TARGET|D3DCLEAR_ZBUFFER,D3DCOLOR_XRGB(243, 152, 0),1.0f,0);
return S_OK;
}
bool GnDirectx9Renderer::Init(guint uiWidth, guint uiHeight, GnWindowHandle hwnd)
{
/// 디바이스를 생성하기위한 D3D객체 생성
if( NULL == ( mpD3D = Direct3DCreate9( D3D_SDK_VERSION ) ) )
return false;
D3DDISPLAYMODE d3ddm;
if( FAILED( mpD3D->GetAdapterDisplayMode( D3DADAPTER_DEFAULT, &d3ddm ) ) )
return false;
CollectDevieceInfo();
D3DPRESENT_PARAMETERS d3dpp;
ZeroMemory( &d3dpp, sizeof(d3dpp) );
d3dpp.Windowed = TRUE;
d3dpp.hDeviceWindow = hwnd;
d3dpp.SwapEffect = D3DSWAPEFFECT_DISCARD;
d3dpp.BackBufferFormat = d3ddm.Format;
d3dpp.EnableAutoDepthStencil = TRUE;
d3dpp.AutoDepthStencilFormat = D3DFMT_D16;
d3dpp.BackBufferWidth = uiWidth;
d3dpp.BackBufferHeight = uiHeight;
d3dpp.FullScreen_RefreshRateInHz = 0;
d3dpp.PresentationInterval = D3DPRESENT_INTERVAL_IMMEDIATE;
DWORD dwVSProcess = ( mD3DCaps9.VertexShaderVersion < D3DVS_VERSION(1,0) )
? D3DCREATE_SOFTWARE_VERTEXPROCESSING : D3DCREATE_HARDWARE_VERTEXPROCESSING;
if( FAILED( mpD3D->CreateDevice( D3DADAPTER_DEFAULT, D3DDEVTYPE_HAL, hwnd, dwVSProcess, &d3dpp, &mpDevice ) ) )
{
return false;
}
GnDX92DBuffer* defaultBuffer = GnDX9SwapChainBuffer::Create(d3dpp, mpDevice);
if( defaultBuffer == NULL )
{
GnLog(GnText("Failed Create BackBuffer"));
return false;
}
mpDefaultRenderTarget = GnRenderTarget::Create(defaultBuffer);
SetDynamicLight();
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;
}
