void InitGpuInfo() { DXUTDeviceSettings setting = DXUTGetDeviceSettings(); CD3D9Enumeration* pd3dEnum = DXUTGetD3D9Enumeration(); CD3D9EnumAdapterInfo* info = pd3dEnum->GetAdapterInfo( setting.d3d9.AdapterOrdinal ); #ifdef UNICODE MultiByteToWideChar(CP_ACP, 0, info->AdapterIdentifier.Description, -1, gEnv->pSystemInfo->gpuDesc, 255); #else _tcscpy( gEnv->pSystemInfo->gpuDesc, info->AdapterIdentifier.Description ); #endif gEnv->pSystemInfo->gpuVendorID = info->AdapterIdentifier.VendorId; }
HRESULT CVolumeRaycasting::OnResetDevice(LPDIRECT3DDEVICE9 pD3DDevice) { CObject::OnResetDevice( pD3DDevice ); m_fxShader = CShaderManager::GetInstance()->GetShader( m_hShader ); if(!m_pVolume || !m_fxShader) return E_FAIL; HRESULT hr; D3DPRESENT_PARAMETERS pp = DXUTGetDeviceSettings().d3d9.pp; SAFE_RELEASE( m_pBack ); V_RETURN( D3DXCreateTexture(m_pD3DDevice, pp.BackBufferWidth, pp.BackBufferHeight, 1, D3DUSAGE_RENDERTARGET, pp.BackBufferFormat, D3DPOOL_DEFAULT, &m_pBack)); SAFE_RELEASE( m_pFront ); V_RETURN( D3DXCreateTexture(m_pD3DDevice, pp.BackBufferWidth, pp.BackBufferHeight, 1, D3DUSAGE_RENDERTARGET, pp.BackBufferFormat, D3DPOOL_DEFAULT, &m_pFront)); int iWidth = m_pVolume->m_iWidth, iHeight = m_pVolume->m_iHeight, iDepth = m_pVolume->m_iDepth; float maxSize = (float)max(iWidth, max(iHeight, iDepth)); D3DXVECTOR3 stepSize(1.0f / (iWidth * (maxSize / iWidth)), 1.0f / (iHeight * (maxSize / iHeight)), 1.0f / (iDepth * (maxSize / iDepth))); float mStepScale = 0.5; stepSize = stepSize * mStepScale; m_fxShader->SetFloatArray("SampleDist", (const FLOAT*)&stepSize, 3); m_fxShader->SetFloat("ActualSampleDist", mStepScale); m_fxShader->SetInt("Iterations", (int)(maxSize * (1.0f / mStepScale) * 2.0f)); //calculate the scale factor //volumes are not always perfect cubes. so we need to scale our cube //by the sizes of the volume. Also, scalar data is not always sampled //at equidistant steps. So we also need to scale the cube model by mRatios. D3DXVECTOR4 ratios( iWidth / maxSize, iHeight / maxSize, iDepth / maxSize, 1.0f); m_fxShader->SetFloatArray("ScaleFactor", (const FLOAT*)&ratios, 4); m_fxShader->SetTexture( "Volume", m_pVolume->m_pVolumeTexture ); m_fxShader->SetTexture( "Transfer", m_pVolume->m_pTransferFunction ); return D3D_OK; }
//-------------------------------------------------------------------------------------- HRESULT CD3D11Enumeration::EnumerateDevices( _In_ CD3D11EnumAdapterInfo* pAdapterInfo ) { HRESULT hr; DXUTDeviceSettings deviceSettings = DXUTGetDeviceSettings(); const D3D_DRIVER_TYPE devTypeArray[] = { D3D_DRIVER_TYPE_HARDWARE, D3D_DRIVER_TYPE_WARP, D3D_DRIVER_TYPE_REFERENCE }; const UINT devTypeArrayCount = sizeof( devTypeArray ) / sizeof( devTypeArray[0] ); // Enumerate each Direct3D device type for( UINT iDeviceType = 0; iDeviceType < devTypeArrayCount; iDeviceType++ ) { CD3D11EnumDeviceInfo* pDeviceInfo = new (std::nothrow) CD3D11EnumDeviceInfo; if( !pDeviceInfo ) return E_OUTOFMEMORY; // Fill struct w/ AdapterOrdinal and D3D_DRIVER_TYPE pDeviceInfo->AdapterOrdinal = pAdapterInfo->AdapterOrdinal; pDeviceInfo->DeviceType = devTypeArray[iDeviceType]; D3D_FEATURE_LEVEL FeatureLevels[] = { D3D_FEATURE_LEVEL_11_1, D3D_FEATURE_LEVEL_11_0, D3D_FEATURE_LEVEL_10_1, D3D_FEATURE_LEVEL_10_0, D3D_FEATURE_LEVEL_9_3, D3D_FEATURE_LEVEL_9_2, D3D_FEATURE_LEVEL_9_1 }; UINT NumFeatureLevels = ARRAYSIZE( FeatureLevels ); // Call D3D11CreateDevice to ensure that this is a D3D11 device. ID3D11Device* pd3dDevice = nullptr; ID3D11DeviceContext* pd3dDeviceContext = nullptr; IDXGIAdapter* pAdapter = nullptr; hr = DXUT_Dynamic_D3D11CreateDevice( pAdapter, devTypeArray[iDeviceType], ( HMODULE )0, 0, FeatureLevels, NumFeatureLevels, D3D11_SDK_VERSION, &pd3dDevice, &pDeviceInfo->MaxLevel, &pd3dDeviceContext ); if ( hr == E_INVALIDARG ) { // DirectX 11.0 runtime will not recognize FL 11.1, so try without it hr = DXUT_Dynamic_D3D11CreateDevice( pAdapter, devTypeArray[iDeviceType], ( HMODULE )0, 0, &FeatureLevels[1], NumFeatureLevels - 1, D3D11_SDK_VERSION, &pd3dDevice, &pDeviceInfo->MaxLevel, &pd3dDeviceContext ); } if( FAILED( hr ) || pDeviceInfo->MaxLevel < deviceSettings.MinimumFeatureLevel) { delete pDeviceInfo; continue; } if (m_forceFL == 0 || m_forceFL == pDeviceInfo->MaxLevel) { pDeviceInfo->SelectedLevel = pDeviceInfo->MaxLevel; } else if (m_forceFL > pDeviceInfo->MaxLevel) { delete pDeviceInfo; SAFE_RELEASE( pd3dDevice ); SAFE_RELEASE( pd3dDeviceContext ); continue; } else { // A device was created with a higher feature level that the user-specified feature level. SAFE_RELEASE( pd3dDevice ); SAFE_RELEASE( pd3dDeviceContext ); D3D_FEATURE_LEVEL rtFL; hr = DXUT_Dynamic_D3D11CreateDevice( pAdapter, devTypeArray[iDeviceType], ( HMODULE )0, 0, &m_forceFL, 1, D3D11_SDK_VERSION, &pd3dDevice, &rtFL, &pd3dDeviceContext ); if( SUCCEEDED( hr ) && rtFL == m_forceFL ) { pDeviceInfo->SelectedLevel = m_forceFL; } else { delete pDeviceInfo; if ( SUCCEEDED(hr) ) { SAFE_RELEASE( pd3dDevice ); SAFE_RELEASE( pd3dDeviceContext ); } continue; } } IDXGIDevice1* pDXGIDev = nullptr; hr = pd3dDevice->QueryInterface( __uuidof( IDXGIDevice1 ), ( LPVOID* )&pDXGIDev ); if( SUCCEEDED( hr ) && pDXGIDev ) { SAFE_RELEASE( pAdapterInfo->m_pAdapter ); pDXGIDev->GetAdapter( &pAdapterInfo->m_pAdapter ); } SAFE_RELEASE( pDXGIDev ); D3D11_FEATURE_DATA_D3D10_X_HARDWARE_OPTIONS ho; hr = pd3dDevice->CheckFeatureSupport(D3D11_FEATURE_D3D10_X_HARDWARE_OPTIONS, &ho, sizeof(ho)); if ( FAILED(hr) ) memset( &ho, 0, sizeof(ho) ); pDeviceInfo->ComputeShaders_Plus_RawAndStructuredBuffers_Via_Shader_4_x = ho.ComputeShaders_Plus_RawAndStructuredBuffers_Via_Shader_4_x; SAFE_RELEASE( pd3dDeviceContext ); SAFE_RELEASE( pd3dDevice ); pAdapterInfo->deviceInfoList.push_back( pDeviceInfo ); } return S_OK; }
//-------------------------------------------------------------------------------------- // Create any D3D11 resources that aren't dependant on the back buffer //-------------------------------------------------------------------------------------- HRESULT CALLBACK OnD3D11CreateDevice( ID3D11Device* pd3dDevice, const DXGI_SURFACE_DESC* pBackBufferSurfaceDesc, void* pUserContext ) { HRESULT hr; static bool bFirstOnCreateDevice = true; // Warn the user that in order to support CS4x, a non-hardware device has been created, continue or quit? if ( DXUTGetDeviceSettings().d3d11.DriverType != D3D_DRIVER_TYPE_HARDWARE && bFirstOnCreateDevice ) { if ( MessageBox( 0, L"CS4x capability is missing. "\ L"In order to continue, a non-hardware device has been created, "\ L"it will be very slow, continue?", L"Warning", MB_ICONEXCLAMATION | MB_YESNO ) != IDYES ) return E_FAIL; } bFirstOnCreateDevice = false; ID3D11DeviceContext* pd3dImmediateContext = DXUTGetD3D11DeviceContext(); V_RETURN( g_DialogResourceManager.OnD3D11CreateDevice( pd3dDevice, pd3dImmediateContext ) ); V_RETURN( g_D3DSettingsDlg.OnD3D11CreateDevice( pd3dDevice ) ); V_RETURN( g_Tessellator.OnD3D11CreateDevice( pd3dDevice ) ); g_pTxtHelper = new CDXUTTextHelper( pd3dDevice, pd3dImmediateContext, &g_DialogResourceManager, 15 ); // find the file WCHAR str[MAX_PATH]; V_RETURN( DXUTFindDXSDKMediaFileCch( str, MAX_PATH, L"BaseMesh.obj" ) ); std::wifstream ifs( str ); WCHAR line[256] = {0}; CGrowableArray<D3DXVECTOR4> initdata; // Parse the .obj file. Both triangle faces and quad faces are supported. // Only v and f tags are processed, other tags like vn, vt etc are ignored. { CGrowableArray<D3DXVECTOR4> v; while ( ifs >> line ) { if ( 0 == wcscmp( line, L"#" ) ) ifs.getline( line, 255 ); else if ( 0 == wcscmp( line, L"v" ) ) { D3DXVECTOR4 pos; ifs >> pos.x >> pos.y >> pos.z; pos.w = 1; v.Add( pos ); } } ifs.clear( 0 ); ifs.seekg( 0 ); while ( ifs >> line ) { if ( 0 == wcscmp( line, L"#" ) ) ifs.getline( line, 255 ); else if ( 0 == wcscmp( line, L"f" ) ) { ifs.getline( line, 255 ); std::wstringstream ss(line); int idx[4], i = 0; while ( ss >> line ) { std::wstringstream ss(line); ss >> idx[i++]; } initdata.Add( v[idx[0]-1] ); initdata.Add( v[idx[1]-1] ); initdata.Add( v[idx[2]-1] ); if ( i >= 4 ) // quad face? { initdata.Add( v[idx[2]-1] ); initdata.Add( v[idx[3]-1] ); initdata.Add( v[idx[0]-1] ); } } }
int WINAPI wWinMain( HINSTANCE hInstance, HINSTANCE hPrevInstance, LPWSTR lpCmdLine, int nCmdShow ) { // Enable run-time memory check for debug builds. #if defined(DEBUG) | defined(_DEBUG) _CrtSetDbgFlag(_CRTDBG_ALLOC_MEM_DF | _CRTDBG_LEAK_CHECK_DF); #endif Initialize(); // Set DXUT callbacks DXUTSetCallbackDeviceChanging( ModifyDeviceSettings ); DXUTSetCallbackMsgProc( MsgProc ); DXUTSetCallbackKeyboard( OnKeyboard ); DXUTSetCallbackMouse( OnMouse, true ); DXUTSetCallbackD3D11DeviceAcceptable( IsD3D11DeviceAcceptable ); DXUTSetCallbackD3D11DeviceCreated( OnD3D11CreateDevice ); DXUTSetCallbackD3D11SwapChainResized( OnD3D11ResizedSwapChain ); DXUTSetCallbackD3D11FrameRender( OnD3D11FrameRender ); DXUTSetCallbackD3D11SwapChainReleasing( OnD3D11ReleasingSwapChain ); DXUTSetCallbackD3D11DeviceDestroyed( OnD3D11DestroyDevice ); InitApp(); if (gMultithreaded) { InitWin32Threads(); } DXUTInit( true, true, NULL ); DXUTSetCursorSettings( true, true ); DXUTCreateWindow( L"ISPC HDR Texture Compressor" ); // Try to create a device with DX11 feature set DXUTCreateDevice (D3D_FEATURE_LEVEL_11_0, true, 1280, 1024 ); BOOL DX11Available = false; // If we don't have an adequate driver, then we revert to DX10 feature set... DXUTDeviceSettings settings = DXUTGetDeviceSettings(); if(settings.d3d11.DriverType == D3D_DRIVER_TYPE_UNKNOWN || settings.d3d11.DriverType == D3D_DRIVER_TYPE_NULL) { DXUTCreateDevice(D3D_FEATURE_LEVEL_10_1, true, 1280, 1024); // !HACK! Force enumeration here in order to relocate hardware with new feature level DXUTGetD3D11Enumeration(true); DXUTCreateDevice(D3D_FEATURE_LEVEL_10_1, true, 1280, 1024); const TCHAR *noDx11msg = _T("Your hardware does not seem to support DX11. BC7 Compression is disabled."); MessageBox(NULL, noDx11msg, _T("Error"), MB_OK); } else { DX11Available = true; } FillProfiles(DX11Available); DXUTMainLoop(); // Destroy all of the threads... DestroyThreads(); return DXUTGetExitCode(); }
void MagnifyTool::CreateDepthStencil( ID3D10Device* pd3dDevice, IDXGISwapChain *pSwapChain, const DXGI_SURFACE_DESC* pBackBufferSurfaceDesc, void* pUserContext ) { DXGI_FORMAT DepthFormat; HRESULT hr; SAFE_RELEASE( m_pDepthStencil ); SAFE_RELEASE( m_pDSV ); SAFE_RELEASE( m_pRState ); switch( DXUTGetDeviceSettings().d3d10.AutoDepthStencilFormat ) { case DXGI_FORMAT_D32_FLOAT: DepthFormat = DXGI_FORMAT_R32_TYPELESS; break; case DXGI_FORMAT_D24_UNORM_S8_UINT: DepthFormat = DXGI_FORMAT_R24G8_TYPELESS; break; case DXGI_FORMAT_D16_UNORM: DepthFormat = DXGI_FORMAT_R16_TYPELESS; break; default: DepthFormat = DXGI_FORMAT_UNKNOWN; break; } assert( DepthFormat != DXGI_FORMAT_UNKNOWN ); // Create depth stencil texture D3D10_TEXTURE2D_DESC descDepth; descDepth.Width = pBackBufferSurfaceDesc->Width; descDepth.Height = pBackBufferSurfaceDesc->Height; descDepth.MipLevels = 1; descDepth.ArraySize = 1; descDepth.Format = DepthFormat; descDepth.SampleDesc.Count = DXUTGetDeviceSettings().d3d10.sd.SampleDesc.Count; descDepth.SampleDesc.Quality = DXUTGetDeviceSettings().d3d10.sd.SampleDesc.Quality; descDepth.Usage = D3D10_USAGE_DEFAULT; descDepth.BindFlags = D3D10_BIND_DEPTH_STENCIL; if( ( descDepth.SampleDesc.Count == 1 ) || DXUTGetD3D10Device1() ) { descDepth.BindFlags |= D3D10_BIND_SHADER_RESOURCE; } descDepth.CPUAccessFlags = 0; descDepth.MiscFlags = 0; hr = pd3dDevice->CreateTexture2D( &descDepth, NULL, &m_pDepthStencil ); assert( D3D_OK == hr ); // Create the depth stencil view D3D10_DEPTH_STENCIL_VIEW_DESC descDSV; descDSV.Format = DXUTGetDeviceSettings().d3d10.AutoDepthStencilFormat; if( descDepth.SampleDesc.Count > 1 ) { descDSV.ViewDimension = D3D10_DSV_DIMENSION_TEXTURE2DMS; } else { descDSV.ViewDimension = D3D10_DSV_DIMENSION_TEXTURE2D; } descDSV.Texture2D.MipSlice = 0; hr = pd3dDevice->CreateDepthStencilView( m_pDepthStencil, &descDSV, &m_pDSV ); assert( D3D_OK == hr ); // Create a default rasterizer state that enables MSAA D3D10_RASTERIZER_DESC RSDesc; RSDesc.FillMode = D3D10_FILL_SOLID; RSDesc.CullMode = D3D10_CULL_BACK; RSDesc.FrontCounterClockwise = FALSE; RSDesc.DepthBias = 0; RSDesc.SlopeScaledDepthBias = 0.0f; RSDesc.DepthBias = 0; RSDesc.DepthClipEnable = TRUE; RSDesc.ScissorEnable = FALSE; RSDesc.AntialiasedLineEnable = FALSE; if( descDepth.SampleDesc.Count > 1 ) { RSDesc.MultisampleEnable = TRUE; } else { RSDesc.MultisampleEnable = FALSE; } hr = pd3dDevice->CreateRasterizerState( &RSDesc, &m_pRState ); assert( D3D_OK == hr ); pd3dDevice->RSSetState( m_pRState ); // Get the current render and depth targets, so we can later revert to these. ID3D10RenderTargetView *pRenderTargetView; DXUTGetD3D10Device()->OMGetRenderTargets( 1, &pRenderTargetView, NULL ); // Bind our render target view to the OM stage. DXUTGetD3D10Device()->OMSetRenderTargets( 1, (ID3D10RenderTargetView* const*)&pRenderTargetView, m_pDSV ); // Decrement the counter on these resources SAFE_RELEASE( pRenderTargetView ); }