void GraphicsDevice::CreateDeviceAndSwapChain() { //Init swapchain desc DXGI_SWAP_CHAIN_DESC swapChainDesc={}; //Swapchain characteristics swapChainDesc.BufferDesc.Width = m_MainViewportInfo.width; swapChainDesc.BufferDesc.Height = m_MainViewportInfo.height; swapChainDesc.BufferDesc.RefreshRate.Numerator = 60; swapChainDesc.BufferDesc.RefreshRate.Denominator = 1; swapChainDesc.BufferDesc.Format = DXGI_FORMAT_R8G8B8A8_UNORM; swapChainDesc.BufferDesc.ScanlineOrdering = DXGI_MODE_SCANLINE_ORDER_UNSPECIFIED; swapChainDesc.BufferDesc.Scaling = DXGI_MODE_SCALING_UNSPECIFIED; //Disable anti-aliasing swapChainDesc.SampleDesc.Count = 1; swapChainDesc.SampleDesc.Quality = 0; //Swapchain to window swapChainDesc.BufferUsage = DXGI_USAGE_RENDER_TARGET_OUTPUT | DXGI_USAGE_SHADER_INPUT; swapChainDesc.BufferCount = 1; swapChainDesc.OutputWindow = m_hWindow; swapChainDesc.Windowed = true; swapChainDesc.SwapEffect = DXGI_SWAP_EFFECT_DISCARD; swapChainDesc.Flags = DXGI_SWAP_CHAIN_FLAG_ALLOW_MODE_SWITCH; UINT createDeviceFlags = 0; #ifndef NDEBUG createDeviceFlags |= D3D10_CREATE_DEVICE_DEBUG; #endif HR(D3D10CreateDeviceAndSwapChain(0, D3D10_DRIVER_TYPE_HARDWARE, 0, createDeviceFlags, D3D10_SDK_VERSION, &swapChainDesc, &m_pSwapChain, &m_pD3DDevice)); }
bool CRenderDevice::DeviceAndSwapChain(HRESULT& hr, HWND hWnd) { RECT rc; ZeroMemory( &rc, sizeof(rc) ); GetClientRect( hWnd, &rc ); m_ViewWidth = rc.right - rc.left; m_ViewHeight = rc.bottom - rc.top; DXGI_SWAP_CHAIN_DESC sd; ZeroMemory( &sd, sizeof( sd ) ); sd.BufferCount = 1; sd.BufferDesc.Width = m_ViewWidth; // Target window size sd.BufferDesc.Height = m_ViewHeight; // --"-- sd.BufferDesc.Format = DXGI_FORMAT_R8G8B8A8_UNORM; // Pixel format of target window sd.BufferDesc.RefreshRate.Numerator = 60; // Refresh rate of monitor sd.BufferDesc.RefreshRate.Denominator = 1; // --"-- sd.BufferUsage = DXGI_USAGE_RENDER_TARGET_OUTPUT; sd.SampleDesc.Count = 1; sd.SampleDesc.Quality = 0; sd.OutputWindow = hWnd; // Target window sd.Windowed = TRUE; // Whether to render in a window (TRUE) or go fullscreen (FALSE) hr = D3D10CreateDeviceAndSwapChain( NULL, D3D10_DRIVER_TYPE_HARDWARE, NULL, 0, D3D10_SDK_VERSION, &sd, &m_pSwapChain, &m_pd3dDevice ); if( FAILED( hr ) ) { MessageBox( NULL, "NO DEVICE OR SWAP CHAIN", "", NULL ); return false; } return true; }
HRESULT CreateDeviceD3D(HWND hWnd) { // Setup swap chain DXGI_SWAP_CHAIN_DESC sd; ZeroMemory(&sd, sizeof(sd)); sd.BufferCount = 2; sd.BufferDesc.Width = 0; sd.BufferDesc.Height = 0; sd.BufferDesc.Format = DXGI_FORMAT_R8G8B8A8_UNORM; sd.BufferDesc.RefreshRate.Numerator = 60; sd.BufferDesc.RefreshRate.Denominator = 1; sd.Flags = DXGI_SWAP_CHAIN_FLAG_ALLOW_MODE_SWITCH; sd.BufferUsage = DXGI_USAGE_RENDER_TARGET_OUTPUT; sd.OutputWindow = hWnd; sd.SampleDesc.Count = 1; sd.SampleDesc.Quality = 0; sd.Windowed = TRUE; sd.SwapEffect = DXGI_SWAP_EFFECT_DISCARD; UINT createDeviceFlags = 0; //createDeviceFlags |= D3D10_CREATE_DEVICE_DEBUG; if (D3D10CreateDeviceAndSwapChain(NULL, D3D10_DRIVER_TYPE_HARDWARE, NULL, createDeviceFlags, D3D10_SDK_VERSION, &sd, &g_pSwapChain, &g_pd3dDevice) != S_OK) return E_FAIL; CreateRenderTarget(); return S_OK; }
void Window::initDirect3D() { //Create swap chain. DXGI_SWAP_CHAIN_DESC sd; sd.BufferDesc.Width = windowWidth; sd.BufferDesc.Height = windowHeight; sd.BufferDesc.RefreshRate.Numerator = 60; sd.BufferDesc.RefreshRate.Denominator = 1; sd.BufferDesc.Format = DXGI_FORMAT_R8G8B8A8_UNORM; sd.BufferDesc.ScanlineOrdering = DXGI_MODE_SCANLINE_ORDER_UNSPECIFIED; sd.BufferDesc.Scaling = DXGI_MODE_SCALING_UNSPECIFIED; sd.SampleDesc.Count = 1; sd.SampleDesc.Quality = 0; sd.BufferUsage = DXGI_USAGE_RENDER_TARGET_OUTPUT; sd.BufferCount = 1; sd.OutputWindow = hMainWnd; sd.Windowed = true; sd.SwapEffect = DXGI_SWAP_EFFECT_DISCARD; sd.Flags = 0; //Create DirectX device. UINT createDeviceFlags = 0; #if defined(DEBUG) || defined(_DEBUG) createDeviceFlags |= D3D10_CREATE_DEVICE_DEBUG; #endif HR(D3D10CreateDeviceAndSwapChain(0, d3dDriverType, 0, createDeviceFlags, D3D10_SDK_VERSION, &sd, &swapChain, &d3dDevice)); //Create backbuffer etc, used here to prevents duplication of code onResize(); }
bool D3DContext::CreateDeviceAndSwapChain(Description description) { unsigned int deviceFlags = 0; #ifdef DEBUG_MODE deviceFlags |= D3D10_CREATE_DEVICE_DEBUG; #endif // Create the swap chain description description.BackBuffer.Width = (description.BackBuffer.Width == 0) ? mTargetWindow->GetClientWidth() : description.BackBuffer.Width; description.BackBuffer.Height = (description.BackBuffer.Height == 0) ? mTargetWindow->GetClientHeight() : description.BackBuffer.Height; DXGI_SWAP_CHAIN_DESC scDescription; ZeroMemory(&scDescription, sizeof(scDescription)); scDescription.BufferCount = 1; scDescription.BufferDesc.Width = description.BackBuffer.Width; scDescription.BufferDesc.Height = description.BackBuffer.Height; scDescription.BufferDesc.Format = DXGI_FORMAT_R8G8B8A8_UNORM; scDescription.BufferDesc.RefreshRate.Numerator = 60; scDescription.BufferDesc.RefreshRate.Denominator = 1; scDescription.BufferUsage = DXGI_USAGE_RENDER_TARGET_OUTPUT; scDescription.OutputWindow = mTargetWindow->GetHandle(); scDescription.SampleDesc.Count = 1; scDescription.SampleDesc.Quality = 0; scDescription.Windowed = !description.Fullscreen; // Create the device and the swap chain // Try different drivers for Direct3D, hardware first, reference only if that fails. D3D10_DRIVER_TYPE driverTypes[] = { D3D10_DRIVER_TYPE_HARDWARE, D3D10_DRIVER_TYPE_REFERENCE }; unsigned int driverTypeCount = sizeof(driverTypes) / sizeof(driverTypes[0]); HRESULT result = S_OK; for (unsigned int i = 0; i < driverTypeCount; ++i) { result = D3D10CreateDeviceAndSwapChain(NULL, driverTypes[i], NULL, deviceFlags, D3D10_SDK_VERSION, &scDescription, &mSwapChain, &mDevice); if (SUCCEEDED(result)) break; } if (FAILED(result)) return false; mBackBufferSize.Width = description.BackBuffer.Width; mBackBufferSize.Height = description.BackBuffer.Height; return true; }
HRESULT CreateDeviceD3D(HWND hWnd) { // Setup swap chain DXGI_SWAP_CHAIN_DESC sd; { ZeroMemory(&sd, sizeof(sd)); sd.BufferCount = 2; sd.BufferDesc.Width = 0; sd.BufferDesc.Height = 0; sd.BufferDesc.Format = DXGI_FORMAT_R8G8B8A8_UNORM; sd.BufferDesc.RefreshRate.Numerator = 60; sd.BufferDesc.RefreshRate.Denominator = 1; sd.Flags = DXGI_SWAP_CHAIN_FLAG_ALLOW_MODE_SWITCH; sd.BufferUsage = DXGI_USAGE_RENDER_TARGET_OUTPUT; sd.OutputWindow = hWnd; sd.SampleDesc.Count = 1; sd.SampleDesc.Quality = 0; sd.Windowed = TRUE; sd.SwapEffect = DXGI_SWAP_EFFECT_DISCARD; } UINT createDeviceFlags = 0; //createDeviceFlags |= D3D10_CREATE_DEVICE_DEBUG; if (D3D10CreateDeviceAndSwapChain(NULL, D3D10_DRIVER_TYPE_HARDWARE, NULL, createDeviceFlags, D3D10_SDK_VERSION, &sd, &g_pSwapChain, &g_pd3dDevice) != S_OK) return E_FAIL; // Setup rasterizer { D3D10_RASTERIZER_DESC RSDesc; memset(&RSDesc, 0, sizeof(D3D10_RASTERIZER_DESC)); RSDesc.FillMode = D3D10_FILL_SOLID; RSDesc.CullMode = D3D10_CULL_NONE; RSDesc.FrontCounterClockwise = FALSE; RSDesc.DepthBias = 0; RSDesc.SlopeScaledDepthBias = 0.0f; RSDesc.DepthBiasClamp = 0; RSDesc.DepthClipEnable = TRUE; RSDesc.ScissorEnable = TRUE; RSDesc.AntialiasedLineEnable = FALSE; RSDesc.MultisampleEnable = (sd.SampleDesc.Count > 1) ? TRUE : FALSE; ID3D10RasterizerState* pRState = NULL; g_pd3dDevice->CreateRasterizerState(&RSDesc, &pRState); g_pd3dDevice->RSSetState(pRState); pRState->Release(); } CreateRenderTarget(); return S_OK; }
void D3DApp::initDirect3D() { // Fill out a DXGI_SWAP_CHAIN_DESC to describe our swap chain. DXGI_SWAP_CHAIN_DESC sd; sd.BufferDesc.Width = mClientWidth; sd.BufferDesc.Height = mClientHeight; sd.BufferDesc.RefreshRate.Numerator = 60; sd.BufferDesc.RefreshRate.Denominator = 1; sd.BufferDesc.Format = DXGI_FORMAT_R8G8B8A8_UNORM; sd.BufferDesc.ScanlineOrdering = DXGI_MODE_SCANLINE_ORDER_UNSPECIFIED; sd.BufferDesc.Scaling = DXGI_MODE_SCALING_UNSPECIFIED; // Multisampling. sd.SampleDesc.Count = 8; sd.SampleDesc.Quality = 0; sd.BufferUsage = DXGI_USAGE_RENDER_TARGET_OUTPUT; sd.BufferCount = 1; sd.OutputWindow = mhMainWnd; sd.Windowed = true; sd.SwapEffect = DXGI_SWAP_EFFECT_DISCARD; sd.Flags = 0; // Create the device. UINT createDeviceFlags = 0; #if defined(DEBUG) || defined(_DEBUG) createDeviceFlags |= D3D10_CREATE_DEVICE_DEBUG; #endif HR( D3D10CreateDeviceAndSwapChain( 0, //default adapter md3dDriverType, 0, // no software device createDeviceFlags, D3D10_SDK_VERSION, &sd, &mSwapChain, &md3dDevice) ); // The remaining steps that need to be carried out for d3d creation // also need to be executed every time the window is resized. So // just call the onResize method here to avoid code duplication. onResize(); }
bool DirectX10Renderer::CreateSwapChainAndDevice() { DEBUG_OUT("DirectX10Renderer::CreateSwapChainAndDevice"); DXGI_SWAP_CHAIN_DESC swapChainDesc; ZeroMemory(&swapChainDesc, sizeof(swapChainDesc)); //set buffer dimensions and format swapChainDesc.BufferCount = 2; swapChainDesc.BufferDesc.Width = m_ScreenWidth; swapChainDesc.BufferDesc.Height = m_ScreenHeight; swapChainDesc.BufferUsage = DXGI_USAGE_RENDER_TARGET_OUTPUT; swapChainDesc.BufferDesc.Format = DXGI_FORMAT_R8G8B8A8_UNORM; //set refresh rate swapChainDesc.BufferDesc.RefreshRate.Numerator = 60; swapChainDesc.BufferDesc.RefreshRate.Denominator = 1; //sampling settings swapChainDesc.SampleDesc.Quality = 0; swapChainDesc.SampleDesc.Count = 1; //output window handle swapChainDesc.OutputWindow = *hWnd; swapChainDesc.Windowed = true; //Create the D3D device //-------------------------------------------------------------- HRESULT result = D3D10CreateDeviceAndSwapChain( NULL, D3D10_DRIVER_TYPE_HARDWARE, NULL, 0, D3D10_SDK_VERSION, &swapChainDesc, &pSwapChain, &pD3DDevice ); if(FAILED(result)) { return FatalError("D3D device creation failed"); } return true; }
bool DX10_Init3d() { HRESULT hr = S_OK; RECT rc; GetClientRect( g_hWnd, &rc ); UINT width = rc.right - rc.left; UINT height = rc.bottom - rc.top; UINT createDeviceFlags = 0; D3D10_DRIVER_TYPE driverTypes[] = { D3D10_DRIVER_TYPE_HARDWARE, D3D10_DRIVER_TYPE_REFERENCE, }; UINT numDriverTypes = sizeof( driverTypes ) / sizeof( driverTypes[0] ); DXGI_SWAP_CHAIN_DESC sd; ZeroMemory( &sd, sizeof( sd ) ); sd.BufferCount = 1; sd.BufferDesc.Width = width; sd.BufferDesc.Height = height; sd.BufferDesc.Format = DXGI_FORMAT_R8G8B8A8_UNORM; sd.BufferDesc.RefreshRate.Numerator = 60; sd.BufferDesc.RefreshRate.Denominator = 1; sd.BufferUsage = DXGI_USAGE_RENDER_TARGET_OUTPUT; sd.OutputWindow = g_hWnd; sd.SampleDesc.Count = 1; sd.SampleDesc.Quality = 0; sd.Windowed = TRUE; for( UINT driverTypeIndex = 0; driverTypeIndex < numDriverTypes; driverTypeIndex++ ) { g_driverType = driverTypes[driverTypeIndex]; hr = D3D10CreateDeviceAndSwapChain( NULL, g_driverType, NULL, createDeviceFlags, D3D10_SDK_VERSION, &sd, &g_pSwapChainDX10, &g_pd3dDeviceDX10 ); if( SUCCEEDED( hr ) ) break; } if( FAILED( hr ) ) return false; return true; }
HRESULT QD3D10Widget::createSwapChainAndDevice( int width, int height ) { UINT createDeviceFlags = 0; #ifdef _DEBUG createDeviceFlags |= D3D10_CREATE_DEVICE_DEBUG; #endif DXGI_SWAP_CHAIN_DESC sd; ZeroMemory( &sd, sizeof( sd ) ); sd.BufferCount = 1; sd.BufferDesc.Width = width; sd.BufferDesc.Height = height; sd.BufferDesc.Format = DXGI_FORMAT_R8G8B8A8_UNORM; sd.BufferDesc.RefreshRate.Numerator = 0; sd.BufferDesc.RefreshRate.Denominator = 0; sd.BufferUsage = DXGI_USAGE_RENDER_TARGET_OUTPUT; sd.OutputWindow = winId(); sd.SampleDesc.Count = 1; sd.SampleDesc.Quality = 0; sd.SwapEffect = DXGI_SWAP_EFFECT_DISCARD; sd.Windowed = TRUE; D3D10_DRIVER_TYPE driverType = D3D10_DRIVER_TYPE_HARDWARE; // create the device and the swap chain HRESULT hr = D3D10CreateDeviceAndSwapChain ( NULL, // existing DXGI adapter driverType, // driver type NULL, // HMODULE pointing to loaded software rasterizer dll createDeviceFlags, // device creation flags D3D10_SDK_VERSION, // DX sdk version &sd, // swap chain description &m_pSwapChain, // output swap chain &m_pDevice // output device ); return hr; }
RenderingSystem::RenderingSystem(Window* Window) : m_Running(true), m_Window(Window) { HRESULT hr = 0; DXGI_SWAP_CHAIN_DESC SwapChainDesc; ZeroMemory(&SwapChainDesc, sizeof(SwapChainDesc)); SwapChainDesc.BufferCount = 1; //Set the width and Height of the back buffer SwapChainDesc.BufferDesc.Width = m_Window->getWidth(); SwapChainDesc.BufferDesc.Height = m_Window->getHeight(); //Set the surface to be 32 bit SwapChainDesc.BufferDesc.Format = DXGI_FORMAT_R8G8B8A8_UNORM; //Set the refresh rate to be 60 frames per second SwapChainDesc.BufferDesc.RefreshRate.Numerator = 60; SwapChainDesc.BufferDesc.RefreshRate.Denominator = 1; SwapChainDesc.BufferUsage = DXGI_USAGE_RENDER_TARGET_OUTPUT; //Set the output Window SwapChainDesc.OutputWindow = m_Window->getWindowHandle(); //No multisampling at the moment SwapChainDesc.SampleDesc.Count = 1; SwapChainDesc.SampleDesc.Quality = 0; //Windowed mode SwapChainDesc.Windowed = TRUE; hr = D3D10CreateDeviceAndSwapChain(NULL, //Use the default Adapter D3D10_DRIVER_TYPE_HARDWARE, NULL, //Not using DLL for rendering D3D10_CREATE_DEVICE_DEBUG, //Allow debug output D3D10_SDK_VERSION, //use the current SDK &SwapChainDesc, &m_SwapChain, &m_Device); }
bool Screen::createSCandDevice() { ZeroMemory(&swapChainDesc, sizeof(swapChainDesc)); swapChainDesc.BufferCount = 1; swapChainDesc.BufferDesc.Width = width; swapChainDesc.BufferDesc.Height = height; swapChainDesc.BufferDesc.Format = DXGI_FORMAT_R8G8B8A8_UNORM; swapChainDesc.BufferUsage = DXGI_USAGE_RENDER_TARGET_OUTPUT; swapChainDesc.OutputWindow = rndrWindow; swapChainDesc.SampleDesc.Count = settings.getNumSamples(); swapChainDesc.SampleDesc.Quality = settings.getNumSamples()-1; swapChainDesc.Windowed = TRUE; HRESULT hr = D3D10CreateDeviceAndSwapChain(NULL, D3D10_DRIVER_TYPE_HARDWARE, NULL, D3D10_CREATE_DEVICE_PREVENT_INTERNAL_THREADING_OPTIMIZATIONS | D3D10_CREATE_DEVICE_SINGLETHREADED||D3D10_CREATE_DEVICE_DEBUG, D3D10_SDK_VERSION, &swapChainDesc, &swapChain, &d3ddev); if (FAILED(hr)) { MessageBox(NULL, "Error initializing Direct3D\n\n*This is usually caused by the configuration being unsupported by your graphics card, or your graphics card not supporting DirectX 10.\n\n*Try lowering and/or disabling some settings in the software config.\n\n*This may also have been caused by outdated graphics card drivers. Please make sure your graphics drivers are up to date.\n\n*If you are running a system with Nvidia Optimus, please make sure the software is running on the dedicated GPU.\n\n*Unfortunately, if your graphics card does not support DirectX 10, the only fix for this would be to use one that does.", "Fatal Error", MB_OK); return false; } return true; }
HRESULT Engine::D3DDeviceSetup( UINT width, UINT height, UINT createDeviceFlags ) { HRESULT hr = S_OK; D3D10_DRIVER_TYPE driverTypes[] = { D3D10_DRIVER_TYPE_HARDWARE, D3D10_DRIVER_TYPE_REFERENCE, }; UINT numDriverTypes = sizeof( driverTypes ) / sizeof( driverTypes[0] ); DXGI_SWAP_CHAIN_DESC swapChain; ZeroMemory( &swapChain, sizeof( swapChain ) ); swapChain.BufferCount = 1; swapChain.BufferDesc.Width = width; swapChain.BufferDesc.Height = height; swapChain.BufferDesc.Format = DXGI_FORMAT_R8G8B8A8_UNORM_SRGB; swapChain.BufferDesc.RefreshRate.Numerator = 60; swapChain.BufferDesc.RefreshRate.Denominator = 1; swapChain.BufferUsage = DXGI_USAGE_RENDER_TARGET_OUTPUT; swapChain.OutputWindow = myWindowHandler; swapChain.SampleDesc.Count = 1; swapChain.SampleDesc.Quality = 0; swapChain.Windowed = TRUE; for( UINT driverTypeIndex = 0; driverTypeIndex < numDriverTypes; driverTypeIndex++ ) { myDriverType = driverTypes[driverTypeIndex]; hr = D3D10CreateDeviceAndSwapChain( NULL, myDriverType, NULL, createDeviceFlags, D3D10_SDK_VERSION, &swapChain, &mySwapChain, &my3DDevice ); if( SUCCEEDED( hr ) ) break; } return hr; }
bool CVideo::Reset(int width, int height, bool fullscreen) { Shutdown(); if (SDL_Init(SDL_INIT_VIDEO) < 0) return false; Uint32 flags = SDL_WINDOW_SHOWN; if (fullscreen) flags |= SDL_WINDOW_FULLSCREEN; window_ = SDL_CreateWindow("Demo", SDL_WINDOWPOS_CENTERED, SDL_WINDOWPOS_CENTERED, width, height, flags); if (!window_) { SDL_Quit(); return false; } SDL_SysWMinfo wminfo; SDL_VERSION(&wminfo.version); if (!SDL_GetWindowWMInfo(window_, &wminfo)) { SDL_Quit(); return false; } hWnd_ = wminfo.info.win.window; hInstance_ = (HINSTANCE)GetWindowLong(hWnd_, GWL_HINSTANCE); RECT dimensions; GetClientRect(hWnd_, &dimensions); unsigned int w = dimensions.right - dimensions.left; unsigned int h = dimensions.bottom - dimensions.top; D3D10_DRIVER_TYPE driverTypes[] = { D3D10_DRIVER_TYPE_HARDWARE, D3D10_DRIVER_TYPE_WARP, D3D10_DRIVER_TYPE_REFERENCE }; unsigned int totalDriverTypes = ARRAYSIZE(driverTypes); DXGI_SWAP_CHAIN_DESC swapChainDesc; ZeroMemory(&swapChainDesc, sizeof(swapChainDesc)); swapChainDesc.BufferCount = 1; swapChainDesc.BufferDesc.Width = w; swapChainDesc.BufferDesc.Height = h; swapChainDesc.BufferDesc.Format = DXGI_FORMAT_R8G8B8A8_UNORM; swapChainDesc.BufferDesc.RefreshRate.Numerator = 60; swapChainDesc.BufferDesc.RefreshRate.Denominator = 1; swapChainDesc.BufferUsage = DXGI_USAGE_RENDER_TARGET_OUTPUT; swapChainDesc.OutputWindow = hWnd_; swapChainDesc.Windowed = true; swapChainDesc.SampleDesc.Count = 1; swapChainDesc.SampleDesc.Quality = 0; unsigned int creationFlags = 0; HRESULT result; unsigned int driver = 0; for (driver = 0; driver < totalDriverTypes; ++driver) { result = D3D10CreateDeviceAndSwapChain(0, driverTypes[driver], 0, creationFlags, D3D10_SDK_VERSION, &swapChainDesc, &swapChain_, &d3dDevice_); if (SUCCEEDED(result)) { driverType_ = driverTypes[driver]; break; } } if (FAILED(result)) return false; ID3D10Texture2D *backBufferTexture; result = swapChain_->GetBuffer(0, __uuidof(ID3D10Texture2D), (LPVOID*)&backBufferTexture); if (FAILED(result)) return false; result = d3dDevice_->CreateRenderTargetView(backBufferTexture, 0, &backBufferTarget_); if (backBufferTexture) backBufferTexture->Release(); if (FAILED(result)) return false; D3D10_TEXTURE2D_DESC depthTexDesc; ZeroMemory(&depthTexDesc, sizeof(depthTexDesc)); depthTexDesc.Width = w; depthTexDesc.Height = h; depthTexDesc.MipLevels = 1; depthTexDesc.ArraySize = 1; depthTexDesc.Format = DXGI_FORMAT_D24_UNORM_S8_UINT; depthTexDesc.SampleDesc.Count = 1; depthTexDesc.SampleDesc.Quality = 0; depthTexDesc.Usage = D3D10_USAGE_DEFAULT; depthTexDesc.BindFlags = D3D10_BIND_DEPTH_STENCIL; result = d3dDevice_->CreateTexture2D(&depthTexDesc, NULL, &depthTexture_); if (FAILED(result)) return false; D3D10_DEPTH_STENCIL_VIEW_DESC descDSV; ZeroMemory(&descDSV, sizeof(descDSV)); descDSV.Format = depthTexDesc.Format; descDSV.ViewDimension = D3D10_DSV_DIMENSION_TEXTURE2D; descDSV.Texture2D.MipSlice = 0; result = d3dDevice_->CreateDepthStencilView(depthTexture_, &descDSV, &depthStencilView_); if (FAILED(result)) return false; d3dDevice_->OMSetRenderTargets(1, &backBufferTarget_, depthStencilView_); D3D10_VIEWPORT viewport; viewport.Height = h; viewport.Width = w; viewport.MinDepth = 0.0f; viewport.MaxDepth = 1.0f; viewport.TopLeftX = 0; viewport.TopLeftY = 0; d3dDevice_->RSSetViewports(1, &viewport); initialized_ = true; return true; }
//----------------------------------------------------------------------------// bool CEGuiD3D10BaseApplication::initialiseDirect3D(unsigned int width, unsigned int height, bool windowed) { HRESULT res; // init sqap chain descriptor structure DXGI_SWAP_CHAIN_DESC scd; ZeroMemory(&scd, sizeof(scd)); scd.BufferCount = 1; scd.BufferDesc.Width = width; scd.BufferDesc.Height = height; scd.BufferDesc.Format = DXGI_FORMAT_R8G8B8A8_UNORM; scd.BufferDesc.RefreshRate.Numerator = 60; scd.BufferDesc.RefreshRate.Denominator = 1; scd.BufferUsage = DXGI_USAGE_RENDER_TARGET_OUTPUT; scd.OutputWindow = pimpl->d_window; scd.SampleDesc.Count = 1; scd.SampleDesc.Quality = 0; scd.Windowed = windowed; // initialise main parts of D3D res = D3D10CreateDeviceAndSwapChain(0, D3D10_DRIVER_TYPE_HARDWARE, 0, 0, D3D10_SDK_VERSION, &scd, &pimpl->d_swapChain, &pimpl->d_device); if (SUCCEEDED(res)) { // obtain handle to thr back buffer of the swap chain ID3D10Texture2D* back_buffer; res = pimpl->d_swapChain->GetBuffer(0, __uuidof(ID3D10Texture2D), (LPVOID*)&back_buffer); if (SUCCEEDED(res)) { ID3D10RenderTargetView* rtview; // create render target view using the back buffer res = pimpl->d_device-> CreateRenderTargetView(back_buffer, 0, &rtview); // release handle to buffer - we have done all we needed to with it. back_buffer->Release(); if (SUCCEEDED(res)) { // bind the back-buffer render target to get the output. pimpl->d_device-> OMSetRenderTargets(1, &rtview, 0); // set a basic viewport. D3D10_VIEWPORT view_port; view_port.Width = width; view_port.Height = height; view_port.MinDepth = 0.0f; view_port.MaxDepth = 1.0f; view_port.TopLeftX = 0; view_port.TopLeftY = 0; pimpl->d_device->RSSetViewports(1, &view_port); // complete window initialisation ShowWindow(pimpl->d_window, SW_NORMAL); UpdateWindow(pimpl->d_window); return true; } rtview->Release(); } pimpl->d_swapChain->Release(); pimpl->d_device->Release(); pimpl->d_swapChain = 0; pimpl->d_device = 0; } MessageBox(0, "Failed to correctly initialise Direct3D 10", Win32AppHelper::APPLICATION_NAME, MB_ICONERROR|MB_OK); return false; }
bool CDX10Renderer::Initialise(HINSTANCE _hInstance, HWND _hwnd, int _iClientWidth, int _iClientHeight) { m_hAppInst = _hInstance; m_hMainWnd = _hwnd; m_iTargetWidth = _iClientWidth; m_iTargetHeight = _iClientHeight; m_iClientWidth = _iClientWidth; m_iClientHeight = _iClientHeight; // Set up DX swap chain DXGI_SWAP_CHAIN_DESC sd; sd.BufferDesc.Width = m_iTargetWidth; sd.BufferDesc.Height = m_iTargetHeight; sd.BufferDesc.RefreshRate.Numerator = 60; sd.BufferDesc.RefreshRate.Denominator = 1; sd.BufferDesc.Format = DXGI_FORMAT_R8G8B8A8_UNORM; sd.BufferDesc.ScanlineOrdering = DXGI_MODE_SCANLINE_ORDER_UNSPECIFIED; sd.BufferDesc.Scaling = DXGI_MODE_SCALING_UNSPECIFIED; sd.SampleDesc.Count = 1; sd.SampleDesc.Quality = 0; sd.BufferUsage = DXGI_USAGE_RENDER_TARGET_OUTPUT; sd.BufferCount = 1; sd.OutputWindow = m_hMainWnd; sd.Windowed = true; sd.SwapEffect = DXGI_SWAP_EFFECT_DISCARD; sd.Flags = 0; // Create DX10 device UINT createDeviceFlags = 0; #if defined(DEBUG) || defined(_DEBUG) createDeviceFlags |= D3D10_CREATE_DEVICE_DEBUG; #endif // Create the ID3D10Device and IDXGISwapChain which interfaces // with the D3D10CreateDeviceAndSwapChain function if(FAILED(D3D10CreateDeviceAndSwapChain(0, //default adapter D3D10_DRIVER_TYPE_HARDWARE, 0, // no software device createDeviceFlags, D3D10_SDK_VERSION, &sd, &m_pSwapChain, &m_pDevice))) { MessageBoxA(0, "Failed to create DX10 device.", "ERROR", MB_OK); return (false); } // Create raster states. And set an initial state D3D10_RASTERIZER_DESC rsDesc; ZeroMemory(&rsDesc, sizeof(D3D10_RASTERIZER_DESC)); // Make backface cull solid and set this as initial state rsDesc.FillMode = D3D10_FILL_SOLID; rsDesc.CullMode = D3D10_CULL_BACK; m_pDevice->CreateRasterizerState(&rsDesc, &m_pDefaultRasterState); m_pDevice->RSSetState(m_pDefaultRasterState); Resize(m_iClientWidth, m_iClientHeight); // Load the effect if (FAILED(D3DX10CreateEffectFromFile(L"default.fx", 0, 0, "fx_4_0", D3D10_SHADER_ENABLE_STRICTNESS, 0, m_pDevice, 0, 0, &m_pDefaultEffect, 0, 0))) { MessageBoxA(0, "Failed to create DX10 device.", "ERROR", MB_OK); return (false); } m_pDefaultTech = m_pDefaultEffect->GetTechniqueByName("DefaultTech"); // Create matrix effect pointers m_pWorldMatrixEffectVariable = m_pDefaultEffect->GetVariableByName( "gWorld" )->AsMatrix(); m_pViewMatrixEffectVariable = m_pDefaultEffect->GetVariableByName( "gView" )->AsMatrix(); m_pProjectionMatrixEffectVariable = m_pDefaultEffect->GetVariableByName( "gProjection" )->AsMatrix(); // Vert layout D3D10_INPUT_ELEMENT_DESC layout[] = { { "POSITION", 0, DXGI_FORMAT_R32G32B32_FLOAT, 0, 0, D3D10_INPUT_PER_VERTEX_DATA, 0 }, { "COLOR", 0, DXGI_FORMAT_R32G32B32A32_FLOAT, 0, 12, D3D10_INPUT_PER_VERTEX_DATA, 0 } }; UINT numElements = 2; D3D10_PASS_DESC passDesc; m_pDefaultTech->GetPassByIndex(0)->GetDesc(&passDesc); if (FAILED(m_pDevice->CreateInputLayout(layout, numElements, passDesc.pIAInputSignature, passDesc.IAInputSignatureSize, &m_pDefaultVertexInputLayout ) ) ) { MessageBoxA(0, "Failed to create DX10 device.", "ERROR", MB_OK); return (false); }; // Set the input layout m_pDevice->IASetInputLayout(m_pDefaultVertexInputLayout); m_pDevice->IASetPrimitiveTopology(D3D10_PRIMITIVE_TOPOLOGY_TRIANGLESTRIP); // Set effect values now because they will not change D3DXMATRIX world; D3DXMatrixIdentity(&world); D3DXMatrixTranslation(&world, m_iClientWidth * -0.5f, m_iClientHeight * -0.5f, 0.0f); D3DXMATRIX rot; D3DXMatrixRotationX(&rot, static_cast<float>(D3DX_PI)); world = world * rot; // Set up the view matrix //-------------------------------------------------------------- D3DXVECTOR3 eye(0.0f, 0.0f, -1.0f); D3DXVECTOR3 view(0.0f, 0.0f, 0.0f); D3DXVECTOR3 up(0.0f, 1.0f, 0.0f); D3DXMATRIX viewMatrix; D3DXMatrixLookAtLH( &viewMatrix, &eye, &view, &up); //Set up projection matrix //-------------------------------------------------------------- D3DXMATRIX projectionMatrix; D3DXMatrixOrthoLH(&projectionMatrix, static_cast<float>(m_iClientWidth), static_cast<float>(m_iClientHeight), 0.0f, 1.0f); //D3DXMatrixPerspectiveFovLH(&projectionMatrix, (float)D3DX_PI * 0.5f, (float)m_iClientWidth/m_iClientHeight, 0.1f, 100.0f); m_pWorldMatrixEffectVariable->SetMatrix(world); m_pViewMatrixEffectVariable->SetMatrix(viewMatrix); m_pProjectionMatrixEffectVariable->SetMatrix(projectionMatrix); D3D10_TECHNIQUE_DESC techDesc; m_pDefaultTech->GetDesc(&techDesc); for(unsigned int p = 0; p < techDesc.Passes; ++p ) { m_pDefaultTech->GetPassByIndex(p)->Apply(0); } //create vertex buffer (space for 100 vertices) //--------------------------------------------- UINT numVertices = 100; D3D10_BUFFER_DESC bd; bd.Usage = D3D10_USAGE_DYNAMIC; bd.ByteWidth = sizeof( TVertex ) * numVertices; //total size of buffer in bytes bd.BindFlags = D3D10_BIND_VERTEX_BUFFER; bd.CPUAccessFlags = D3D10_CPU_ACCESS_WRITE; bd.MiscFlags = 0; if ( FAILED( m_pDevice->CreateBuffer( &bd, 0, &m_pVertexBuffer ) ) ) { MessageBoxA(0, "Failed to create DX10 device.", "ERROR", MB_OK); return (false); } PushPenColour(TColour(0, 0, 0, 255).Value()); PushBrushColour(TColour(0, 0, 0, 255).Value()); // Init font D3DX10_FONT_DESC fontDesc; fontDesc.Height = 16; fontDesc.Width = 0; fontDesc.Weight = 0; fontDesc.MipLevels = 1; fontDesc.Italic = false; fontDesc.CharSet = DEFAULT_CHARSET; fontDesc.OutputPrecision = OUT_DEFAULT_PRECIS; fontDesc.Quality = DEFAULT_QUALITY; fontDesc.PitchAndFamily = DEFAULT_PITCH | FF_DONTCARE; wcscpy_s(fontDesc.FaceName, L"Times New Roman"); D3DX10CreateFontIndirect(m_pDevice, &fontDesc, &m_pFont); D3DX10CreateSprite(m_pDevice, 512, &m_pSprite); return(true); }
// Create Direct3D device and swap chain HRESULT DxWidget::InitDevice() { HRESULT hrResult = E_FAIL; HRESULT hrRetCode = E_FAIL; m_driverType = D3D10_DRIVER_TYPE_NULL; UINT createDeviceFlags = 0; D3D10_DRIVER_TYPE driverTypes[] = { D3D10_DRIVER_TYPE_HARDWARE, D3D10_DRIVER_TYPE_REFERENCE, }; UINT numDriverTypes = sizeof(driverTypes) / sizeof(driverTypes[0]); ZeroMemory(&m_swapChainDesc, sizeof(m_swapChainDesc)); m_swapChainDesc.BufferCount = 1; m_swapChainDesc.BufferDesc.Width = width(); m_swapChainDesc.BufferDesc.Height = height(); m_swapChainDesc.BufferDesc.Format = DXGI_FORMAT_R8G8B8A8_UNORM; m_swapChainDesc.BufferDesc.RefreshRate.Numerator = 60; m_swapChainDesc.BufferDesc.RefreshRate.Denominator = 1; m_swapChainDesc.BufferUsage = DXGI_USAGE_RENDER_TARGET_OUTPUT; m_swapChainDesc.OutputWindow = (HWND)winId(); m_swapChainDesc.SampleDesc.Count = 1; m_swapChainDesc.SampleDesc.Quality = 0; m_swapChainDesc.Windowed = TRUE; for(UINT driverTypeIndex = 0; driverTypeIndex < numDriverTypes; driverTypeIndex++) { m_driverType = driverTypes[driverTypeIndex]; hrRetCode = D3D10CreateDeviceAndSwapChain(NULL, m_driverType, NULL, createDeviceFlags, D3D10_SDK_VERSION, &m_swapChainDesc, &m_pSwapChain, &m_pd3dDevice); if(SUCCEEDED(hrRetCode)) break; } KE_COM_PROCESS_ERROR(hrRetCode); KE_PROCESS_ERROR(m_pSwapChain); KE_PROCESS_ERROR(m_pd3dDevice); // Create a render target view ID3D10Texture2D* pBackBuffer; hrRetCode = m_pSwapChain->GetBuffer(0, __uuidof( ID3D10Texture2D ), ( LPVOID* )&pBackBuffer); KE_COM_PROCESS_ERROR(hrRetCode); KE_PROCESS_ERROR(pBackBuffer); hrRetCode = m_pd3dDevice->CreateRenderTargetView(pBackBuffer, NULL, &m_pRenderTargetView); pBackBuffer->Release(); KE_COM_PROCESS_ERROR(hrRetCode); KE_PROCESS_ERROR(m_pRenderTargetView); m_pd3dDevice->OMSetRenderTargets(1, &m_pRenderTargetView, NULL); // Setup the viewport m_viewPort.Width = width(); m_viewPort.Height = height(); m_viewPort.MinDepth = 0.0f; m_viewPort.MaxDepth = 1.0f; m_viewPort.TopLeftX = 0; m_viewPort.TopLeftY = 0; m_pd3dDevice->RSSetViewports(1, &m_viewPort); // Create the effect DWORD dwShaderFlags = D3D10_SHADER_ENABLE_STRICTNESS; hrRetCode = D3DX10CreateEffectFromFile(L"testqt.fx", NULL, NULL, "fx_4_0", dwShaderFlags, 0, m_pd3dDevice, NULL, NULL, &m_pEffect, NULL, NULL ); KE_COM_PROCESS_ERROR(hrRetCode); KE_PROCESS_ERROR(m_pEffect); // Obtain the technique m_pTechnique = m_pEffect->GetTechniqueByName("Render"); // Define the input layout D3D10_INPUT_ELEMENT_DESC layout[] = { {"POSITION", 0, DXGI_FORMAT_R32G32B32_FLOAT, 0, 0, D3D10_INPUT_PER_VERTEX_DATA, 0}, {"COLOR", 0, DXGI_FORMAT_R32G32B32A32_FLOAT, 0, 12, D3D10_INPUT_PER_VERTEX_DATA, 0}, }; UINT numElements = sizeof(layout) / sizeof(layout[0]); // Create the input layout D3D10_PASS_DESC PassDesc; m_pTechnique->GetPassByIndex(0)->GetDesc(&PassDesc); hrRetCode = m_pd3dDevice->CreateInputLayout(layout, numElements, PassDesc.pIAInputSignature, PassDesc.IAInputSignatureSize, &m_pVertexLayout); KE_COM_PROCESS_ERROR(hrRetCode); KE_PROCESS_ERROR(m_pVertexLayout); // Set the input layout m_pd3dDevice->IASetInputLayout(m_pVertexLayout); // Set primitive topology m_pd3dDevice->IASetPrimitiveTopology(D3D10_PRIMITIVE_TOPOLOGY_LINELIST); hrResult = S_OK; Exit0: return hrResult; }
bool ds::Render::Create( HWND Handle, const ds::String& BasicEffect ) { g_SwapChain.OutputWindow = Handle; RECT Rect; GetClientRect( Handle, &Rect ); g_SwapChain.BufferDesc.Width = ( unsigned ) Rect.right - ( unsigned ) Rect.left; g_SwapChain.BufferDesc.Height = ( unsigned ) Rect.bottom - ( unsigned ) Rect.top; for( unsigned i = 0; i < 2; i++ ) { if( SUCCEEDED( D3D10CreateDeviceAndSwapChain( nullptr, ( D3D10_DRIVER_TYPE )i, nullptr, 0, D3D10_SDK_VERSION, &g_SwapChain, &Swap, &Device ) ) ) { if( ( D3D10_DRIVER_TYPE )i == D3D10_DRIVER_TYPE_REFERENCE ) dsPushMessage( ErrRenderCreateDevice ); break; } } if( !Device ) { dsPushErrorStatic( ErrRenderCreateDevice ); return false; } IDXGIOutput* l_Info; unsigned l_ModesCount = 0; Swap->GetContainingOutput( &l_Info ); l_Info->GetDisplayModeList( g_SwapChain.BufferDesc.Format, 0, &l_ModesCount, nullptr ); DXGI_MODE_DESC* l_Modes = new DXGI_MODE_DESC[l_ModesCount]; l_Info->GetDisplayModeList( g_SwapChain.BufferDesc.Format, 0, &l_ModesCount, l_Modes ); for( unsigned i = 0; i < l_ModesCount; i++ ) VideoModes.push_back( VideoMode( ds::Size( l_Modes[i].Width, l_Modes[i].Height ), l_Modes[i].RefreshRate.Numerator / l_Modes[i].RefreshRate.Denominator ) ); delete[] l_Modes; l_Info->Release( ); ID3D10Texture2D* l_BackBuffer = nullptr; if( FAILED( Swap->GetBuffer( 0, __uuidof( ID3D10Texture2D ), ( LPVOID* )&l_BackBuffer ) ) ) return false; if( FAILED( Device->CreateRenderTargetView( l_BackBuffer, nullptr, &RenderTargetView ) ) ) return false; l_BackBuffer->Release( ); CreateDepthBuffer( ds::Size( g_SwapChain.BufferDesc.Width, g_SwapChain.BufferDesc.Height ) ); Device->OMSetRenderTargets( 1, &RenderTargetView, DepthBufferEnable ? DepthStencilView : nullptr ); Device->RSSetViewports( 1, &g_ViewPort ); SetRenderRect( v4<unsigned>( 0, 0, g_SwapChain.BufferDesc.Width, g_SwapChain.BufferDesc.Height ) ); if( !BasicEffect.empty( ) ) Effect = new ds::BasicEffect( BasicEffect, "Render" ); else Effect = nullptr; SetRenderMode( 1 ); SetView( v2<unsigned>( g_SwapChain.BufferDesc.Width, g_SwapChain.BufferDesc.Height ), v2<unsigned>( g_ViewPort.TopLeftX, g_ViewPort.TopLeftY ), g_ViewPort.MinDepth, g_ViewPort.MaxDepth ); ds::Clock::Reset( ); return true; }
HRESULT InitD3D( HWND hWnd ) { // Setup a DXGI swap chain descriptor DXGI_SWAP_CHAIN_DESC sd; ZeroMemory( &sd, sizeof( sd ) ); sd.BufferCount = 1; // number of buffer sd.BufferDesc.Width = 600; // buffer width, can we set it to the screen width? sd.BufferDesc.Height = 600; // buffer height, can we set it to the screen height? sd.BufferDesc.Format = DXGI_FORMAT_R8G8B8A8_UNORM; // buffer format, 32 bit color with alpha(RGBA) sd.BufferDesc.RefreshRate.Numerator = 60; // refresh rate? sd.BufferDesc.RefreshRate.Denominator = 1; // WHAT'S THIS? sd.BufferUsage = DXGI_USAGE_RENDER_TARGET_OUTPUT; // use buffer as render target sd.OutputWindow = hWnd; // output window handle sd.SampleDesc.Count = 1; // WHAT'S THIS? sd.SampleDesc.Quality = 0; // WHAT'S THIS? sd.Windowed = TRUE; // full-screen mode HRESULT hr; UINT flags = D3D10_CREATE_DEVICE_BGRA_SUPPORT; #if defined( DEBUG ) || defined( _DEBUG ) flags |= D3D10_CREATE_DEVICE_DEBUG; #endif // Create device and swap chain if (FAILED (hr = D3D10CreateDeviceAndSwapChain( NULL, D3D10_DRIVER_TYPE_HARDWARE, NULL, flags, D3D10_SDK_VERSION, &sd, &g_pSwapChain, &g_pd3dDevice))) { return hr; } // Create render target and bind the back-buffer ID3D10Texture2D* pBackBuffer; // Get a pointer to the back buffer hr = g_pSwapChain->GetBuffer(0, __uuidof(ID3D10Texture2D), (LPVOID* )&pBackBuffer); if (FAILED(hr)) return hr; // Create a render-target view g_pd3dDevice->CreateRenderTargetView(pBackBuffer, NULL, &g_pRenderTargetView); // Bind the view g_pd3dDevice->OMSetRenderTargets(1, &g_pRenderTargetView, NULL); // WHAT'S OM here mean? // Setup the viewport D3D10_VIEWPORT vp; vp.Width = 640; // this should be similar with the back-buffer width, global it! vp.Height = 480; vp.MinDepth = 0.0f; vp.MaxDepth = 1.0f; vp.TopLeftX = 0; vp.TopLeftY = 0; g_pd3dDevice->RSSetViewports(1, &vp); InitVertexBuffer(); InitEffects(); return S_OK; }
bool DX10App::Init(char* title, int width, int height) { hInstance = GetModuleHandle(0); InitVertexStructures(); mWidth = width; mHeight = height; // To create a window we need to describe some of // it's characteristics by filling out a WNDCLASS structure WNDCLASS wc; wc.style = CS_HREDRAW | CS_VREDRAW; // Repaints window when resized wc.lpfnWndProc = WndProc; wc.cbClsExtra = 0; wc.cbWndExtra = 0; wc.hInstance = hInstance; // Main application instance wc.hIcon = LoadIcon(0, IDI_APPLICATION); wc.hCursor = LoadCursor(0, IDC_ARROW); wc.hbrBackground = (HBRUSH)GetStockObject(BLACK_BRUSH); wc.lpszMenuName = 0; wc.lpszClassName = "Albanien"; // Registers WNDCLASS with windows so that we can create a window based on it if(!RegisterClass(&wc)) { MessageBox(0, "RegisterClass failed.", 0, 0); return false; } // Grab all window border values to adjust the window to the size we want RECT rect; rect.top = (long)0; rect.left = (long)(0); rect.right = (long)width; rect.bottom = (long)height; AdjustWindowRect(&rect, WS_OVERLAPPEDWINDOW, FALSE); hMainWnd = CreateWindow( "Albanien", // Registered WNDCLASS instance to use title, // Window title WS_OVERLAPPEDWINDOW, // Style flags 200/*CW_USEDEFAULT*/, // x-coordinate 200/*CW_USEDEFAULT*/, // y-coordinate rect.right - rect.left, // Width (adjusted width) rect.bottom - rect.top, // Height (adjusted height) 0, // Parent window 0, // Menu handle hInstance, // App instance 0 // ); UINT createDeviceFlags = 0; createDeviceFlags |= D3D10_CREATE_DEVICE_DEBUG; // If debug mode D3D10_DRIVER_TYPE driverTypes[] = { D3D10_DRIVER_TYPE_HARDWARE, D3D10_DRIVER_TYPE_REFERENCE }; UINT numDriverTypes = sizeof(driverTypes) / sizeof(driverTypes[0]); DXGI_SWAP_CHAIN_DESC sd; ZeroMemory(&sd, sizeof(sd)); sd.BufferCount = 1; sd.BufferDesc.Width = width; sd.BufferDesc.Height = height; sd.BufferDesc.Format = DXGI_FORMAT_R8G8B8A8_UNORM; sd.BufferDesc.RefreshRate.Numerator = 60; sd.BufferDesc.RefreshRate.Denominator = 1; sd.BufferUsage = DXGI_USAGE_RENDER_TARGET_OUTPUT; sd.OutputWindow = hMainWnd; sd.SampleDesc.Count = 1; sd.SampleDesc.Quality = 0; sd.Windowed = TRUE; D3D10_DRIVER_TYPE driverType; HRESULT hr; // i == driverTypeIndex for(UINT i = 0; i < numDriverTypes; i++) { driverType = driverTypes[i]; hr = D3D10CreateDeviceAndSwapChain( NULL, driverType, NULL, createDeviceFlags, D3D10_SDK_VERSION, &sd, &mSwapChain, &gDevice ); // If first driver type succeeded, break, else try the other one if(SUCCEEDED(hr)) break; } printf("Device and swap chain created.\n"); mSwapBuffers->setDevice(gDevice); //create rastersizer desc D3D10_RASTERIZER_DESC rasterDesc; rasterDesc.FillMode = D3D10_FILL_SOLID; rasterDesc.CullMode = D3D10_CULL_BACK; rasterDesc.FrontCounterClockwise = false; rasterDesc.DepthBias = false; rasterDesc.DepthBiasClamp = 0; rasterDesc.SlopeScaledDepthBias = 0; rasterDesc.DepthClipEnable = true; rasterDesc.ScissorEnable = false; rasterDesc.MultisampleEnable = true; rasterDesc.AntialiasedLineEnable = true; gDevice->CreateRasterizerState( &rasterDesc, &mSolidMode ); rasterDesc.FillMode = D3D10_FILL_WIREFRAME; rasterDesc.CullMode = D3D10_CULL_BACK; rasterDesc.FrontCounterClockwise = false; rasterDesc.DepthBias = false; rasterDesc.DepthBiasClamp = 0; rasterDesc.SlopeScaledDepthBias = 0; rasterDesc.DepthClipEnable = false; rasterDesc.ScissorEnable = false; rasterDesc.MultisampleEnable = false; rasterDesc.AntialiasedLineEnable = false; gDevice->CreateRasterizerState( &rasterDesc, &mWireframeMode ); gDevice->RSSetState(mSolidMode); mSwapBuffers->createBackBuffer(mSwapChain); printf("Render target view created.\n"); mSwapBuffers->createDepthTexture(); // Viewport settings D3D10_VIEWPORT vp; vp.Width = width; vp.Height = height; vp.MinDepth = 0.0f; vp.MaxDepth = 1.0f; vp.TopLeftX = 0; vp.TopLeftY = 0; mSwapBuffers->setViewPort(&vp); printf("DX10 initiated.\n\n"); ShowWindow(hMainWnd, 1); return true; }
bool C_Graphics::initDirect3D(const C_Window& window) { // Fill out a DXGI_SWAP_CHAIN_DESC to describe our swap chain. DXGI_SWAP_CHAIN_DESC sd; ZeroMemory( &sd, sizeof( sd ) ); sd.BufferDesc.Width = window.getWidth(); sd.BufferDesc.Height = window.getHeight(); sd.BufferDesc.RefreshRate.Numerator = 60; sd.BufferDesc.RefreshRate.Denominator = 1; sd.BufferDesc.Format = DXGI_FORMAT_R8G8B8A8_UNORM; sd.BufferDesc.ScanlineOrdering = DXGI_MODE_SCANLINE_ORDER_UNSPECIFIED; sd.BufferDesc.Scaling = DXGI_MODE_SCALING_UNSPECIFIED; // No multisampling sd.SampleDesc.Count = 1; sd.SampleDesc.Quality = 0; sd.BufferUsage = DXGI_USAGE_RENDER_TARGET_OUTPUT; sd.BufferCount = 1; sd.OutputWindow = window.getWindowHandle(); sd.Windowed = true; sd.SwapEffect = DXGI_SWAP_EFFECT_DISCARD; sd.Flags = 0; // Create the device UINT createDeviceFlags = 0; //#if defined(DEBUG) || defined(_DEBUG) // createDeviceFlags |= D3D10_CREATE_DEVICE_DEBUG; //#endif HRESULT hr = D3D10CreateDeviceAndSwapChain( 0, //default adapter d_D3DDriverType, 0, // no software device createDeviceFlags, D3D10_SDK_VERSION, &sd, &d_SwapChain, &d_D3DDevice); if(FAILED(hr)) { DEBUGLOG(L"D3DDevice INIT FAILED"); DXTrace(__FILE__, (DWORD)__LINE__, hr, 0, true); return false; } DEBUGLOG(L"D3DDevice INIT SUCCESSFUL"); // The remaining steps that need to be carried out for D3D creation // also need to be executed every time the window is resized. So // just call the OnResize method here to avoid code duplication. onResize(window); D3DX10_FONT_DESC fontDesc; fontDesc.Height = 14; fontDesc.Width = 0; fontDesc.Weight = 0; fontDesc.MipLevels = 1; fontDesc.Italic = false; fontDesc.CharSet = DEFAULT_CHARSET; fontDesc.OutputPrecision = OUT_DEFAULT_PRECIS; fontDesc.Quality = DEFAULT_QUALITY; fontDesc.PitchAndFamily = DEFAULT_PITCH | FF_DONTCARE; wcscpy_s(fontDesc.FaceName, L"Times New Roman"); hr = D3DX10CreateFontIndirect(d_D3DDevice, &fontDesc, &d_Font); if(FAILED(hr)) { DEBUGLOG(L"Font INIT FAILED"); return false; } DEBUGLOG(L"Font INIT SUCCESSFUL"); // Init the defualt shader //d_pDefaultShader = new C_DefaultShader(d_D3DDevice); return true; }
bool GSDevice10::Create(HWND hWnd, bool vsync) { if(!__super::Create(hWnd, vsync)) { return false; } HRESULT hr; DXGI_SWAP_CHAIN_DESC scd; D3D10_BUFFER_DESC bd; D3D10_SAMPLER_DESC sd; D3D10_DEPTH_STENCIL_DESC dsd; D3D10_RASTERIZER_DESC rd; D3D10_BLEND_DESC bsd; memset(&scd, 0, sizeof(scd)); scd.BufferCount = 2; scd.BufferDesc.Width = 1; scd.BufferDesc.Height = 1; scd.BufferDesc.Format = DXGI_FORMAT_R8G8B8A8_UNORM; //scd.BufferDesc.RefreshRate.Numerator = 60; //scd.BufferDesc.RefreshRate.Denominator = 1; scd.BufferUsage = DXGI_USAGE_RENDER_TARGET_OUTPUT; scd.OutputWindow = hWnd; scd.SampleDesc.Count = 1; scd.SampleDesc.Quality = 0; scd.Windowed = TRUE; UINT flags = 0; #ifdef DEBUG flags |= D3D10_CREATE_DEVICE_DEBUG; #endif hr = D3D10CreateDeviceAndSwapChain(NULL, D3D10_DRIVER_TYPE_HARDWARE, NULL, flags, D3D10_SDK_VERSION, &scd, &m_swapchain, &m_dev); if(FAILED(hr)) return false; // font /* // TODO: the driver crashes on alt-enter when using a font... D3DX10_FONT_DESC fd; memset(&fd, 0, sizeof(fd)); _tcscpy(fd.FaceName, _T("Arial")); fd.Height = 20; D3DX10CreateFontIndirect(m_dev, &fd, &m_font); */ // convert D3D10_INPUT_ELEMENT_DESC il_convert[] = { {"POSITION", 0, DXGI_FORMAT_R32G32B32A32_FLOAT, 0, 0, D3D10_INPUT_PER_VERTEX_DATA, 0}, {"TEXCOORD", 0, DXGI_FORMAT_R32G32_FLOAT, 0, 16, D3D10_INPUT_PER_VERTEX_DATA, 0}, }; hr = CompileShader(IDR_CONVERT10_FX, "vs_main", NULL, &m_convert.vs, il_convert, countof(il_convert), &m_convert.il); for(int i = 0; i < countof(m_convert.ps); i++) { CStringA main; main.Format("ps_main%d", i); hr = CompileShader(IDR_CONVERT10_FX, main, NULL, &m_convert.ps[i]); } memset(&bd, 0, sizeof(bd)); bd.Usage = D3D10_USAGE_DEFAULT; bd.BindFlags = D3D10_BIND_VERTEX_BUFFER; bd.CPUAccessFlags = 0; bd.MiscFlags = 0; bd.ByteWidth = 4 * sizeof(GSVertexPT1); hr = m_dev->CreateBuffer(&bd, NULL, &m_convert.vb); memset(&dsd, 0, sizeof(dsd)); dsd.DepthEnable = false; dsd.StencilEnable = false; hr = m_dev->CreateDepthStencilState(&dsd, &m_convert.dss); memset(&bsd, 0, sizeof(bsd)); bsd.BlendEnable[0] = false; bsd.RenderTargetWriteMask[0] = D3D10_COLOR_WRITE_ENABLE_ALL; hr = m_dev->CreateBlendState(&bsd, &m_convert.bs); // merge memset(&bd, 0, sizeof(bd)); bd.ByteWidth = sizeof(MergeConstantBuffer); bd.Usage = D3D10_USAGE_DEFAULT; bd.BindFlags = D3D10_BIND_CONSTANT_BUFFER; bd.CPUAccessFlags = 0; bd.MiscFlags = 0; hr = m_dev->CreateBuffer(&bd, NULL, &m_merge.cb); for(int i = 0; i < countof(m_merge.ps); i++) { CStringA main; main.Format("ps_main%d", i); hr = CompileShader(IDR_MERGE10_FX, main, NULL, &m_merge.ps[i]); } memset(&bsd, 0, sizeof(bsd)); bsd.BlendEnable[0] = true; bsd.BlendOp = D3D10_BLEND_OP_ADD; bsd.SrcBlend = D3D10_BLEND_SRC_ALPHA; bsd.DestBlend = D3D10_BLEND_INV_SRC_ALPHA; bsd.BlendOpAlpha = D3D10_BLEND_OP_ADD; bsd.SrcBlendAlpha = D3D10_BLEND_ONE; bsd.DestBlendAlpha = D3D10_BLEND_ZERO; bsd.RenderTargetWriteMask[0] = D3D10_COLOR_WRITE_ENABLE_ALL; hr = m_dev->CreateBlendState(&bsd, &m_merge.bs); // interlace memset(&bd, 0, sizeof(bd)); bd.ByteWidth = sizeof(InterlaceConstantBuffer); bd.Usage = D3D10_USAGE_DEFAULT; bd.BindFlags = D3D10_BIND_CONSTANT_BUFFER; bd.CPUAccessFlags = 0; bd.MiscFlags = 0; hr = m_dev->CreateBuffer(&bd, NULL, &m_interlace.cb); for(int i = 0; i < countof(m_interlace.ps); i++) { CStringA main; main.Format("ps_main%d", i); hr = CompileShader(IDR_INTERLACE10_FX, main, NULL, &m_interlace.ps[i]); } // memset(&rd, 0, sizeof(rd)); rd.FillMode = D3D10_FILL_SOLID; rd.CullMode = D3D10_CULL_NONE; rd.FrontCounterClockwise = false; rd.DepthBias = false; rd.DepthBiasClamp = 0; rd.SlopeScaledDepthBias = 0; rd.DepthClipEnable = false; // ??? rd.ScissorEnable = true; rd.MultisampleEnable = false; rd.AntialiasedLineEnable = false; hr = m_dev->CreateRasterizerState(&rd, &m_rs); m_dev->RSSetState(m_rs); // memset(&sd, 0, sizeof(sd)); sd.Filter = D3D10_FILTER_MIN_MAG_MIP_LINEAR; sd.AddressU = D3D10_TEXTURE_ADDRESS_CLAMP; sd.AddressV = D3D10_TEXTURE_ADDRESS_CLAMP; sd.AddressW = D3D10_TEXTURE_ADDRESS_CLAMP; sd.MaxLOD = FLT_MAX; sd.MaxAnisotropy = 16; sd.ComparisonFunc = D3D10_COMPARISON_NEVER; hr = m_dev->CreateSamplerState(&sd, &m_convert.ln); sd.Filter = D3D10_FILTER_MIN_MAG_MIP_POINT; hr = m_dev->CreateSamplerState(&sd, &m_convert.pt); // Reset(1, 1, true); // /* if(!m_mergefx.Create(this)) { return false; } */ // return true; }
bool Device_D3D10::initD3D( void ) { HRESULT hr = S_OK; // `获得窗口大小` RECT rc; GetClientRect( m_hWnd, &rc ); UINT width = rc.right - rc.left; UINT height = rc.bottom - rc.top; UINT createDeviceFlags = 0; #ifdef _DEBUG createDeviceFlags |= D3D10_CREATE_DEVICE_DEBUG; #endif // `设置Frontbuffer/Backbuffer大小及格式` DXGI_SWAP_CHAIN_DESC sd; ZeroMemory( &sd, sizeof(sd) ); sd.BufferCount = 1; sd.BufferDesc.Width = width; sd.BufferDesc.Height = height; sd.BufferDesc.Format = DXGI_FORMAT_R8G8B8A8_UNORM_SRGB; sd.BufferDesc.RefreshRate.Numerator = 60; sd.BufferDesc.RefreshRate.Denominator = 1; sd.BufferUsage = DXGI_USAGE_RENDER_TARGET_OUTPUT; sd.OutputWindow = m_hWnd; sd.SampleDesc.Count = 1; sd.SampleDesc.Quality = 0; //sd.SwapEffect = DXGI_SWAP_EFFECT_SEQUENTIAL; //sd.Flags = DXGI_SWAP_CHAIN_FLAG_ALLOW_MODE_SWITCH; sd.Windowed = TRUE; // `打开Frontbuffer/Backbuffer` hr = D3D10CreateDeviceAndSwapChain( NULL, D3D10_DRIVER_TYPE_HARDWARE, NULL, createDeviceFlags, D3D10_SDK_VERSION, &sd, &m_pSwapChain, &m_pd3dDevice ); if( FAILED(hr) ) return false; // `取出第一个display buffer` ID3D10Texture2D *pBuffer = NULL; hr = m_pSwapChain->GetBuffer( 0, __uuidof( ID3D10Texture2D ), (LPVOID*)&pBuffer ); if( FAILED(hr) ) return false; // `打开一个合乎display buffer格式的RenderTargetView` hr = m_pd3dDevice->CreateRenderTargetView( pBuffer, NULL, &m_pRenderTargetView ); pBuffer->Release(); if( FAILED( hr ) ) return false; // `设置Depth/Stencil buffer的数据格式` D3D10_TEXTURE2D_DESC descDepth; descDepth.Width = width; descDepth.Height = height; descDepth.MipLevels = 1; descDepth.ArraySize = 1; descDepth.Format = DXGI_FORMAT_D24_UNORM_S8_UINT; descDepth.SampleDesc.Count = 1; descDepth.SampleDesc.Quality = 0; descDepth.Usage = D3D10_USAGE_DEFAULT; descDepth.BindFlags = D3D10_BIND_DEPTH_STENCIL; descDepth.CPUAccessFlags = 0; descDepth.MiscFlags = 0; // `分配Depth/Stencil buffer的空间` hr = m_pd3dDevice->CreateTexture2D( &descDepth, NULL, &m_pDepthStencil ); if( FAILED(hr) ) return false; // `设置Depth/Stencil View的格式` D3D10_DEPTH_STENCIL_VIEW_DESC descDSV; descDSV.Format = descDepth.Format; descDSV.ViewDimension = D3D10_DSV_DIMENSION_TEXTURE2D; descDSV.Texture2D.MipSlice = 0; // `打开DepthStencil Buffer的View` hr = m_pd3dDevice->CreateDepthStencilView( m_pDepthStencil, &descDSV, &m_pDepthStencilView ); if( FAILED(hr) ) return false; setDefaultState(); // `设置绘图的结果会存放在什么地方` // RenderTargetView = RGBA Color Buffer resource // DepthStencilView = Depth/Stencil Buffer resource m_pd3dDevice->OMSetRenderTargets(1, &m_pRenderTargetView, m_pDepthStencilView); setDefaultState(); // `Viewport用来指定3D绘图的画布范围, 在此把Viewport设置成和整个窗口一样大` D3D10_VIEWPORT vp; vp.Width = width; vp.Height = height; vp.MinDepth = 0.0f; vp.MaxDepth = 1.0f; vp.TopLeftX = 0; vp.TopLeftY = 0; m_pd3dDevice->RSSetViewports( 1, &vp ); return true; }
bool DX10Renderer::Initialize(const HWND *pHWND) { //get window dimensions RECT rc; GetClientRect( *pHWND, &rc ); UINT width = rc.right - rc.left; UINT height = rc.bottom - rc.top; /******************************************************************* * Create Swap Chain and D3D device ********************************************************************/ DXGI_SWAP_CHAIN_DESC swapChainDesc; ZeroMemory(&swapChainDesc, sizeof(swapChainDesc)); //set buffer dimensions and format swapChainDesc.BufferCount = 2; swapChainDesc.BufferDesc.Width = width; swapChainDesc.BufferDesc.Height = height; swapChainDesc.BufferUsage = DXGI_USAGE_RENDER_TARGET_OUTPUT; swapChainDesc.BufferDesc.Format = DXGI_FORMAT_R8G8B8A8_UNORM; swapChainDesc.BufferDesc.RefreshRate.Numerator = 60; swapChainDesc.BufferDesc.RefreshRate.Denominator = 1; swapChainDesc.SampleDesc.Quality = 0; swapChainDesc.SampleDesc.Count = 1; swapChainDesc.OutputWindow = *pHWND; swapChainDesc.Windowed = true; //Create the D3D device //-------------------------------------------------------------- // put the d3d device into debug mode under debug profile //-------------------------------------------------------------- UINT flags = 0; #if defined(_DEBUG) | defined(DEBUG) flags |= D3D10_CREATE_DEVICE_DEBUG; #endif if ( FAILED( D3D10CreateDeviceAndSwapChain( NULL, D3D10_DRIVER_TYPE_HARDWARE, NULL, flags, D3D10_SDK_VERSION, &swapChainDesc, &pSwapChain, &pD3DDevice ) ) ) return false; /******************************************************************* * Create Rendering Targets and Depth Stencil ********************************************************************/ //try to get the back buffer ID3D10Texture2D* pBackBuffer; if ( FAILED( pSwapChain->GetBuffer(0, __uuidof(ID3D10Texture2D), (LPVOID*) &pBackBuffer) ) ) return false; //try to create render target view if ( FAILED( pD3DDevice->CreateRenderTargetView(pBackBuffer, NULL, &pRenderTargetView) ) ) return false; pBackBuffer->Release(); //create depth stencil texture desc D3D10_TEXTURE2D_DESC texDesc; texDesc.Width = width; texDesc.Height = height; texDesc.MipLevels = 1; texDesc.ArraySize = 1; texDesc.Format = DXGI_FORMAT_D32_FLOAT; texDesc.SampleDesc.Count = 1; texDesc.SampleDesc.Quality = 0; texDesc.Usage = D3D10_USAGE_DEFAULT; texDesc.BindFlags = D3D10_BIND_DEPTH_STENCIL; texDesc.CPUAccessFlags = 0; texDesc.MiscFlags = 0; // Create the depth stencil view desc D3D10_DEPTH_STENCIL_VIEW_DESC descDSV; descDSV.Format = texDesc.Format; descDSV.ViewDimension = D3D10_DSV_DIMENSION_TEXTURE2D; descDSV.Texture2D.MipSlice = 0; if( FAILED( pD3DDevice->CreateTexture2D( &texDesc, NULL, &pDepthStencil ) ) ) return false; if( FAILED( pD3DDevice->CreateDepthStencilView( pDepthStencil, &descDSV, &pDepthStencilView ) ) ) return false; /******************************************************************* * Create Shadow Map Texture ********************************************************************/ texDesc.Width = width; texDesc.Height = height; texDesc.Format = DXGI_FORMAT_R32_TYPELESS; texDesc.BindFlags = D3D10_BIND_DEPTH_STENCIL | D3D10_BIND_SHADER_RESOURCE; D3D10_SHADER_RESOURCE_VIEW_DESC srvDesc; srvDesc.Format = DXGI_FORMAT_R32_FLOAT; srvDesc.ViewDimension = D3D10_SRV_DIMENSION_TEXTURE2D; srvDesc.Texture2D.MipLevels = texDesc.MipLevels; srvDesc.Texture2D.MostDetailedMip = 0; if( FAILED( pD3DDevice->CreateTexture2D( &texDesc, NULL, &pShadowMap ) ) ) return false; if( FAILED( pD3DDevice->CreateDepthStencilView( pShadowMap, &descDSV, &pShadowMapDepthView ) ) ) return false; if( FAILED( pD3DDevice->CreateShaderResourceView( pShadowMap, &srvDesc, &pShadowMapSRView) ) ) return false; /******************************************************************* * Set up Viewports ********************************************************************/ viewport.Width = width; viewport.Height = height; viewport.MinDepth = 0.0f; viewport.MaxDepth = 1.0f; viewport.TopLeftX = 0; viewport.TopLeftY = 0; shadowMapViewport.Width = width; shadowMapViewport.Height = height; shadowMapViewport.MinDepth = 0.0f; shadowMapViewport.MaxDepth = 1.0f; shadowMapViewport.TopLeftX = 0; shadowMapViewport.TopLeftY = 0; return true; }
bool D3DClass::Initialize(int screenWidth, int screenHeight, bool vsync, HWND hwnd, bool fullscreen, float screenDepth, float screenNear) { HRESULT result; IDXGIFactory* factory; IDXGIAdapter* adapter; IDXGIOutput* adapterOutput; unsigned int numModes, i, numerator, denominator, stringLength; DXGI_MODE_DESC* displayModeList; DXGI_ADAPTER_DESC adapterDesc; int error; DXGI_SWAP_CHAIN_DESC swapChainDesc; ID3D10Texture2D* backBufferPtr; D3D10_TEXTURE2D_DESC depthBufferDesc; D3D10_DEPTH_STENCIL_DESC depthStencilDesc; D3D10_DEPTH_STENCIL_VIEW_DESC depthStencilViewDesc; D3D10_VIEWPORT viewport; float fieldOfView, screenAspect; D3D10_RASTERIZER_DESC rasterDesc; // Store the vsync setting. m_vsync_enabled = vsync; // Create a DirectX graphics interface factory. result = CreateDXGIFactory(__uuidof(IDXGIFactory), (void**)&factory); if(FAILED(result)) { return false; } // Use the factory to create an adapter for the primary graphics interface (video card). result = factory->EnumAdapters(0, &adapter); if(FAILED(result)) { return false; } // Enumerate the primary adapter output (monitor). result = adapter->EnumOutputs(0, &adapterOutput); if(FAILED(result)) { return false; } // Get the number of modes that fit the DXGI_FORMAT_R8G8B8A8_UNORM display format for the adapter output (monitor). result = adapterOutput->GetDisplayModeList(DXGI_FORMAT_R8G8B8A8_UNORM, DXGI_ENUM_MODES_INTERLACED, &numModes, NULL); if(FAILED(result)) { return false; } // Create a list to hold all the possible display modes for this monitor/video card combination. displayModeList = new DXGI_MODE_DESC[numModes]; if(!displayModeList) { return false; } // Now fill the display mode list structures. result = adapterOutput->GetDisplayModeList(DXGI_FORMAT_R8G8B8A8_UNORM, DXGI_ENUM_MODES_INTERLACED, &numModes, displayModeList); if(FAILED(result)) { return false; } // Now go through all the display modes and find the one that matches the screen width and height. // When a match is found store the numerator and denominator of the refresh rate for that monitor. for(i=0; i<numModes; i++) { if(displayModeList[i].Width == (unsigned int)screenWidth) { if(displayModeList[i].Height == (unsigned int)screenHeight) { numerator = displayModeList[i].RefreshRate.Numerator; denominator = displayModeList[i].RefreshRate.Denominator; } } } // Get the adapter (video card) description. result = adapter->GetDesc(&adapterDesc); if(FAILED(result)) { return false; } // Store the dedicated video card memory in megabytes. m_videoCardMemory = (int)(adapterDesc.DedicatedVideoMemory / 1024 / 1024); // Convert the name of the video card to a character array and store it. error = wcstombs_s(&stringLength, m_videoCardDescription, 128, adapterDesc.Description, 128); if(error != 0) { return false; } // Release the display mode list. delete [] displayModeList; displayModeList = 0; // Release the adapter output. adapterOutput->Release(); adapterOutput = 0; // Release the adapter. adapter->Release(); adapter = 0; // Release the factory. factory->Release(); factory = 0; // Initialize the swap chain description. ZeroMemory(&swapChainDesc, sizeof(swapChainDesc)); // Set to a single back buffer. swapChainDesc.BufferCount = 1; // Set the width and height of the back buffer. swapChainDesc.BufferDesc.Width = screenWidth; swapChainDesc.BufferDesc.Height = screenHeight; // Set regular 32-bit surface for the back buffer. swapChainDesc.BufferDesc.Format = DXGI_FORMAT_R8G8B8A8_UNORM; // Set the refresh rate of the back buffer. if(m_vsync_enabled) { swapChainDesc.BufferDesc.RefreshRate.Numerator = numerator; swapChainDesc.BufferDesc.RefreshRate.Denominator = denominator; } else { swapChainDesc.BufferDesc.RefreshRate.Numerator = 0; swapChainDesc.BufferDesc.RefreshRate.Denominator = 1; } // Set the usage of the back buffer. swapChainDesc.BufferUsage = DXGI_USAGE_RENDER_TARGET_OUTPUT; // Set the handle for the window to render to. swapChainDesc.OutputWindow = hwnd; // Turn multisampling off. swapChainDesc.SampleDesc.Count = 1; swapChainDesc.SampleDesc.Quality = 0; // Set to full screen or windowed mode. if(fullscreen) { swapChainDesc.Windowed = false; } else { swapChainDesc.Windowed = true; } // Set the scan line ordering and scaling to unspecified. swapChainDesc.BufferDesc.ScanlineOrdering = DXGI_MODE_SCANLINE_ORDER_UNSPECIFIED; swapChainDesc.BufferDesc.Scaling = DXGI_MODE_SCALING_UNSPECIFIED; // Discard the back buffer contents after presenting. swapChainDesc.SwapEffect = DXGI_SWAP_EFFECT_DISCARD; // Don't set the advanced flags. swapChainDesc.Flags = 0; // Create the swap chain and the Direct3D device. result = D3D10CreateDeviceAndSwapChain(NULL, D3D10_DRIVER_TYPE_HARDWARE, NULL, 0, D3D10_SDK_VERSION, &swapChainDesc, &m_swapChain, &m_device); if(FAILED(result)) { return false; } // Get the pointer to the back buffer. result = m_swapChain->GetBuffer(0, __uuidof(ID3D10Texture2D), (LPVOID*)&backBufferPtr); if(FAILED(result)) { return false; } // Create the render target view with the back buffer pointer. result = m_device->CreateRenderTargetView(backBufferPtr, NULL, &m_renderTargetView); if(FAILED(result)) { return false; } // Release pointer to the back buffer as we no longer need it. backBufferPtr->Release(); backBufferPtr = 0; // Initialize the description of the depth buffer. ZeroMemory(&depthBufferDesc, sizeof(depthBufferDesc)); // Set up the description of the depth buffer. depthBufferDesc.Width = screenWidth; depthBufferDesc.Height = screenHeight; depthBufferDesc.MipLevels = 1; depthBufferDesc.ArraySize = 1; depthBufferDesc.Format = DXGI_FORMAT_D24_UNORM_S8_UINT; depthBufferDesc.SampleDesc.Count = 1; depthBufferDesc.SampleDesc.Quality = 0; depthBufferDesc.Usage = D3D10_USAGE_DEFAULT; depthBufferDesc.BindFlags = D3D10_BIND_DEPTH_STENCIL; depthBufferDesc.CPUAccessFlags = 0; depthBufferDesc.MiscFlags = 0; // Create the texture for the depth buffer using the filled out description. result = m_device->CreateTexture2D(&depthBufferDesc, NULL, &m_depthStencilBuffer); if(FAILED(result)) { return false; } // Initialize the description of the stencil state. ZeroMemory(&depthStencilDesc, sizeof(depthStencilDesc)); // Set up the description of the stencil state. depthStencilDesc.DepthEnable = true; depthStencilDesc.DepthWriteMask = D3D10_DEPTH_WRITE_MASK_ALL; depthStencilDesc.DepthFunc = D3D10_COMPARISON_LESS; depthStencilDesc.StencilEnable = true; depthStencilDesc.StencilReadMask = 0xFF; depthStencilDesc.StencilWriteMask = 0xFF; // Stencil operations if pixel is front-facing. depthStencilDesc.FrontFace.StencilFailOp = D3D10_STENCIL_OP_KEEP; depthStencilDesc.FrontFace.StencilDepthFailOp = D3D10_STENCIL_OP_INCR; depthStencilDesc.FrontFace.StencilPassOp = D3D10_STENCIL_OP_KEEP; depthStencilDesc.FrontFace.StencilFunc = D3D10_COMPARISON_ALWAYS; // Stencil operations if pixel is back-facing. depthStencilDesc.BackFace.StencilFailOp = D3D10_STENCIL_OP_KEEP; depthStencilDesc.BackFace.StencilDepthFailOp = D3D10_STENCIL_OP_DECR; depthStencilDesc.BackFace.StencilPassOp = D3D10_STENCIL_OP_KEEP; depthStencilDesc.BackFace.StencilFunc = D3D10_COMPARISON_ALWAYS; // Create the depth stencil state. result = m_device->CreateDepthStencilState(&depthStencilDesc, &m_depthStencilState); if(FAILED(result)) { return false; } // Set the depth stencil state on the D3D device. m_device->OMSetDepthStencilState(m_depthStencilState, 1); // Initialize the depth stencil view. ZeroMemory(&depthStencilViewDesc, sizeof(depthStencilViewDesc)); // Set up the depth stencil view description. depthStencilViewDesc.Format = DXGI_FORMAT_D24_UNORM_S8_UINT; depthStencilViewDesc.ViewDimension = D3D10_DSV_DIMENSION_TEXTURE2D; depthStencilViewDesc.Texture2D.MipSlice = 0; // Create the depth stencil view. result = m_device->CreateDepthStencilView(m_depthStencilBuffer, &depthStencilViewDesc, &m_depthStencilView); if(FAILED(result)) { return false; } // Bind the render target view and depth stencil buffer to the output render pipeline. m_device->OMSetRenderTargets(1, &m_renderTargetView, m_depthStencilView); // Setup the raster description which will determine how and what polygons will be drawn. rasterDesc.AntialiasedLineEnable = false; rasterDesc.CullMode = D3D10_CULL_BACK; rasterDesc.DepthBias = 0; rasterDesc.DepthBiasClamp = 0.0f; rasterDesc.DepthClipEnable = true; rasterDesc.FillMode = D3D10_FILL_SOLID; rasterDesc.FrontCounterClockwise = false; rasterDesc.MultisampleEnable = false; rasterDesc.ScissorEnable = false; rasterDesc.SlopeScaledDepthBias = 0.0f; // Create the rasterizer state from the description we just filled out. result = m_device->CreateRasterizerState(&rasterDesc, &m_rasterState); if(FAILED(result)) { return false; } // Now set the rasterizer state. m_device->RSSetState(m_rasterState); // Setup the viewport for rendering. viewport.Width = screenWidth; viewport.Height = screenHeight; viewport.MinDepth = 0.0f; viewport.MaxDepth = 1.0f; viewport.TopLeftX = 0; viewport.TopLeftY = 0; // Create the viewport. m_device->RSSetViewports(1, &viewport); // Setup the projection matrix. fieldOfView = (float)D3DX_PI / 4.0f; screenAspect = (float)screenWidth / (float)screenHeight; // Create the projection matrix for 3D rendering. D3DXMatrixPerspectiveFovLH(&m_projectionMatrix, fieldOfView, screenAspect, screenNear, screenDepth); // Initialize the world matrix to the identity matrix. D3DXMatrixIdentity(&m_worldMatrix); // Create an orthographic projection matrix for 2D rendering. D3DXMatrixOrthoLH(&m_orthoMatrix, (float)screenWidth, (float)screenHeight, screenNear, screenDepth); return true; }
bool DX10_Renderer::InitialiseDeviceAndSwapChain() { // State the Driver to be of type HAL m_dx10DriverType = D3D10_DRIVER_TYPE_HARDWARE; // Fill out the DXGI Swap Chain Description structure DXGI_SWAP_CHAIN_DESC swapChainDesc; ZeroMemory(&swapChainDesc, sizeof(swapChainDesc)); swapChainDesc.BufferDesc.Width = m_clientWidth; swapChainDesc.BufferDesc.Height = m_clientHeight; swapChainDesc.BufferDesc.RefreshRate.Numerator = 59; swapChainDesc.BufferDesc.RefreshRate.Denominator = 1; swapChainDesc.BufferDesc.Format = DXGI_FORMAT_R8G8B8A8_UNORM; swapChainDesc.BufferDesc.ScanlineOrdering = DXGI_MODE_SCANLINE_ORDER_UNSPECIFIED; swapChainDesc.BufferDesc.Scaling = DXGI_MODE_SCALING_UNSPECIFIED; // Multi sampling per pixel swapChainDesc.SampleDesc.Count = 1; swapChainDesc.SampleDesc.Quality = 0; swapChainDesc.BufferUsage = DXGI_USAGE_RENDER_TARGET_OUTPUT; swapChainDesc.BufferCount = 1; swapChainDesc.OutputWindow = m_hWnd; swapChainDesc.Windowed = true; swapChainDesc.SwapEffect = DXGI_SWAP_EFFECT_DISCARD; swapChainDesc.Flags = 0; // Add Debug Info to the flags when run in Debug mode UINT createDeviceFlags = 0; #if defined(DEBUG) || defined(_DEBUG) createDeviceFlags |= D3D10_CREATE_DEVICE_DEBUG; #endif // Create the Device and Swap Chain VALIDATEHR( D3D10CreateDeviceAndSwapChain( 0, //default adapter m_dx10DriverType, 0, // no software device createDeviceFlags, D3D10_SDK_VERSION, &swapChainDesc, &m_pDX10SwapChain, &m_pDX10Device)); m_rasterizerDesc.CullMode = D3D10_CULL_BACK; m_rasterizerDesc.FillMode = D3D10_FILL_SOLID; m_rasterizerDesc.FrontCounterClockwise = false; m_rasterizerDesc.DepthBias = 0; m_rasterizerDesc.DepthBiasClamp = 0; m_rasterizerDesc.SlopeScaledDepthBias = 0; m_rasterizerDesc.DepthClipEnable = true; m_rasterizerDesc.ScissorEnable = false; m_rasterizerDesc.MultisampleEnable = false; m_rasterizerDesc.AntialiasedLineEnable = false; m_pDX10Device->CreateRasterizerState(&m_rasterizerDesc, &m_pRasterizerState); m_pDX10Device->RSSetState(m_pRasterizerState); // Create the Rasterizer description for culling clockwise when using reflection D3D10_RASTERIZER_DESC rasterizerDesc; ZeroMemory(&rasterizerDesc, sizeof(rasterizerDesc)); rasterizerDesc.FillMode = D3D10_FILL_SOLID; rasterizerDesc.CullMode = D3D10_CULL_BACK; rasterizerDesc.FrontCounterClockwise = true; VALIDATEHR(m_pDX10Device->CreateRasterizerState(&rasterizerDesc, &m_pRasterizerState_Reflection)); // Invoke functionality that deals with changing size of the window VALIDATE(onResize()); return true; }
//============================================================================================================= bool CGame10::Initialize() { if( Graphics ) return true; HRESULT hr; HWND hwnd; bool success = false; ID3D10Texture2D* backbuffer; D3D10_VIEWPORT vp; int width = (int)DisplayMode.Width; int height = (int)DisplayMode.Height; success = Application.Initialize(width, height, FullScreen); dassert(false, "CGame10::Initialize(): Could not initialize application", success); hwnd = Application.GetWindowHandle(); SwapChainDesc.BufferDesc = DisplayMode; SwapChainDesc.BufferDesc.Width = width; SwapChainDesc.BufferDesc.Height = height; SwapChainDesc.BufferCount = 1; SwapChainDesc.BufferUsage = DXGI_USAGE_RENDER_TARGET_OUTPUT; SwapChainDesc.OutputWindow = hwnd; SwapChainDesc.SampleDesc.Count = 1; SwapChainDesc.SampleDesc.Quality = 0; SwapChainDesc.Windowed = !FullScreen; UINT flags = 0; #ifdef _DEBUG flags |= D3D10_CREATE_DEVICE_DEBUG; #endif hr = D3D10CreateDeviceAndSwapChain(NULL, D3D10_DRIVER_TYPE_HARDWARE, NULL, flags, D3D10_SDK_VERSION, &SwapChainDesc, &SwapChain, &Graphics); dnassert(false, "CGame10::Initialize(): Could not create device", FAILED(hr)); hr = SwapChain->GetBuffer(0, __uuidof(ID3D10Texture2D), (void**)&backbuffer); dnassert(false, "CGame10::Initialize(): Could not get backbuffer", FAILED(hr)); hr = Graphics->CreateRenderTargetView(backbuffer, NULL, &RenderTargetView); backbuffer->Release(); dnassert(false, "CGame10::Initialize(): Could not create render target view", FAILED(hr)); // zbuffer if( ZBuffer ) { D3D10_TEXTURE2D_DESC depthdesc; memset(&depthdesc, 0, sizeof(D3D10_TEXTURE2D_DESC)); depthdesc.Width = width; depthdesc.Height = height; depthdesc.MipLevels = 1; depthdesc.ArraySize = 1; depthdesc.Format = DXGI_FORMAT_D32_FLOAT; depthdesc.SampleDesc.Count = 1; depthdesc.SampleDesc.Quality = 0; depthdesc.Usage = D3D10_USAGE_DEFAULT; depthdesc.BindFlags = D3D10_BIND_DEPTH_STENCIL; hr = Graphics->CreateTexture2D(&depthdesc, NULL, &DepthStencil); dnassert(false, "CGame10::Initialize(): Could not create depth buffer", FAILED(hr)); D3D10_DEPTH_STENCIL_VIEW_DESC dsv; memset(&dsv, 0, sizeof(D3D10_DEPTH_STENCIL_VIEW_DESC)); dsv.Format = depthdesc.Format; dsv.ViewDimension = D3D10_DSV_DIMENSION_TEXTURE2D; dsv.Texture2D.MipSlice = 0; hr = Graphics->CreateDepthStencilView(DepthStencil, &dsv, &DepthStencilView); dnassert(false, "CGame10::Initialize(): Could not create depth stencil view", FAILED(hr)); } Graphics->OMSetRenderTargets(1, &RenderTargetView, DepthStencilView); vp.Width = width; vp.Height = height; vp.MinDepth = 0.0f; vp.MaxDepth = 1.0f; vp.TopLeftX = 0; vp.TopLeftY = 0; Graphics->RSSetViewports(1, &vp); // ... if( fixedtimestep ) Sync.synchronize.connect(this, &CGame10::Update); return true; }
void CreateD3DDevice() { RECT ClientRect; GetClientRect(g_pHWND, &ClientRect); UINT width = ClientRect.right - ClientRect.left; UINT height = ClientRect.bottom - ClientRect.top; D3D10_DRIVER_TYPE driverTypes[] = { D3D10_DRIVER_TYPE_HARDWARE, D3D10_DRIVER_TYPE_WARP, D3D10_DRIVER_TYPE_REFERENCE, }; UINT numDriverTypes = ARRAYSIZE(driverTypes); DXGI_SWAP_CHAIN_DESC sd; ZeroMemory(&sd, sizeof(sd)); sd.BufferCount = 1; sd.BufferUsage = DXGI_USAGE_RENDER_TARGET_OUTPUT; sd.OutputWindow = g_pHWND; sd.SampleDesc.Count = 1; sd.SampleDesc.Quality = 0; sd.Windowed = TRUE; sd.BufferDesc.RefreshRate = { 1, 60 }; sd.BufferDesc.Width = width; sd.BufferDesc.Height = height; sd.BufferDesc.Format = DXGI_FORMAT_R8G8B8A8_UNORM; sd.BufferDesc.Scaling = DXGI_MODE_SCALING_UNSPECIFIED; HRESULT hr = S_OK; for (UINT driverTypeIndex = 0; driverTypeIndex < numDriverTypes; driverTypeIndex++) { hr = D3D10CreateDeviceAndSwapChain(NULL, driverTypes[driverTypeIndex], NULL, D3D10_CREATE_DEVICE_SINGLETHREADED, D3D10_SDK_VERSION, &sd, &g_pSwapChain, &g_pd3dDevice); if (SUCCEEDED(hr)) break; } if (FAILED(hr)) { OutputDebugString(L"Couldn't create D3D Device for some reason!"); return; } // Create a render target view ID3D10Texture2D* pBackBuffer = NULL; hr = g_pSwapChain->GetBuffer(0, __uuidof(ID3D10Texture2D), (LPVOID*)&pBackBuffer); if (FAILED(hr)) { OutputDebugString(L"Couldn't get back buffer from Swap Chain for some reason!"); return; } hr = g_pd3dDevice->CreateRenderTargetView(pBackBuffer, NULL, &g_pRenderTargetView); pBackBuffer->Release(); if (FAILED(hr)) { OutputDebugString(L"Couldn't create render target for some reason!"); return; } g_pd3dDevice->OMSetRenderTargets(1, &g_pRenderTargetView, NULL); // Setup the viewport D3D10_VIEWPORT vp; vp.Width = (FLOAT)width; vp.Height = (FLOAT)height; vp.MinDepth = 0.0f; vp.MaxDepth = 1.0f; vp.TopLeftX = 0; vp.TopLeftY = 0; g_pd3dDevice->RSSetViewports(1, &vp); }
bool initD3DDevice(HWND hWnd) { // Création du device DXGI_SWAP_CHAIN_DESC swapChainDesc; memset(&swapChainDesc, 0, sizeof(swapChainDesc)); swapChainDesc.BufferCount = 1; swapChainDesc.BufferDesc.Width = SCREEN_WIDTH; swapChainDesc.BufferDesc.Height = SCREEN_HEIGHT; swapChainDesc.BufferDesc.Format = DXGI_FORMAT_R8G8B8A8_UNORM; swapChainDesc.BufferDesc.RefreshRate.Numerator = REFRESHRATE; swapChainDesc.BufferDesc.RefreshRate.Denominator = 1; swapChainDesc.BufferUsage = DXGI_USAGE_RENDER_TARGET_OUTPUT; swapChainDesc.OutputWindow = hWnd; swapChainDesc.SampleDesc.Count = 1; swapChainDesc.SampleDesc.Quality = 0; swapChainDesc.Windowed = true; UINT deviceFlags = 0; #ifdef _DEBUG deviceFlags |= D3D10_CREATE_DEVICE_DEBUG; #endif if(FAILED(D3D10CreateDeviceAndSwapChain(NULL, D3D10_DRIVER_TYPE_HARDWARE, NULL, deviceFlags, D3D10_SDK_VERSION, &swapChainDesc, &g_pSwapChain, &g_pD3DDevice))) return false; // Création de la vue ID3D10Texture2D *pBackBuffer; if(FAILED(g_pSwapChain->GetBuffer(0, __uuidof(ID3D10Texture2D), (void **)&pBackBuffer))) return false; HRESULT res = g_pD3DDevice->CreateRenderTargetView(pBackBuffer, NULL, &g_pRenderTargetView); pBackBuffer->Release(); if(FAILED(res)) return false; g_pD3DDevice->OMSetRenderTargets(1, &g_pRenderTargetView, NULL); // Initialisation du viewport D3D10_VIEWPORT viewport; viewport.Width = SCREEN_WIDTH; viewport.Height = SCREEN_HEIGHT; viewport.MinDepth = 0.0f; viewport.MaxDepth = 1.0f; viewport.TopLeftX = 0; viewport.TopLeftY = 0; g_pD3DDevice->RSSetViewports(1, &viewport); // Chargement des shaders DWORD dwShaderFlags = D3D10_SHADER_ENABLE_STRICTNESS; #ifdef _DEBUG dwShaderFlags |= D3D10_SHADER_DEBUG; #endif if(FAILED(D3DX10CreateEffectFromFile("raytracing.fx", NULL, NULL, "fx_4_0", dwShaderFlags, 0, g_pD3DDevice, NULL, NULL, &g_pEffect, NULL, NULL))) return false; // Récupération de la technique g_pTechnique = g_pEffect->GetTechniqueByName("Render"); // Création du input layout D3D10_INPUT_ELEMENT_DESC layout[] = { {"POSITION", 0, DXGI_FORMAT_R32G32B32_FLOAT, 0, D3D10_APPEND_ALIGNED_ELEMENT, D3D10_INPUT_PER_VERTEX_DATA, 0}, {"TEXCOORD", 0, DXGI_FORMAT_R32G32_FLOAT, 0, D3D10_APPEND_ALIGNED_ELEMENT, D3D10_INPUT_PER_VERTEX_DATA, 0}, }; D3D10_PASS_DESC PassDesc; g_pTechnique->GetPassByIndex(0)->GetDesc(&PassDesc); if(FAILED(g_pD3DDevice->CreateInputLayout(layout, 2, PassDesc.pIAInputSignature, PassDesc.IAInputSignatureSize, &g_pVertexLayout))) return false; g_pD3DDevice->IASetInputLayout(g_pVertexLayout); // Création du vertex buffer SimpleVertex vertices[] = { {D3DXVECTOR3(-1.0f, -1.0f, 0.5f), D3DXVECTOR2(0.0f, 0.0f)}, {D3DXVECTOR3(-1.0f, 1.0f, 0.5f), D3DXVECTOR2(0.0f, 1.0f)}, {D3DXVECTOR3(1.0f, -1.0f, 0.5f), D3DXVECTOR2(1.0f, 0.0f)}, {D3DXVECTOR3(1.0f, 1.0f, 0.5f), D3DXVECTOR2(1.0f, 1.0f)} }; D3D10_BUFFER_DESC bd; bd.Usage = D3D10_USAGE_DEFAULT; bd.ByteWidth = sizeof(SimpleVertex)*4; bd.BindFlags = D3D10_BIND_VERTEX_BUFFER; bd.CPUAccessFlags = 0; bd.MiscFlags = 0; D3D10_SUBRESOURCE_DATA InitData; InitData.pSysMem = vertices; if(FAILED(g_pD3DDevice->CreateBuffer(&bd, &InitData, &g_pVertexBuffer))) return false; UINT stride = sizeof(SimpleVertex); UINT offset = 0; g_pD3DDevice->IASetVertexBuffers(0, 1, &g_pVertexBuffer, &stride, &offset); g_pD3DDevice->IASetPrimitiveTopology(D3D10_PRIMITIVE_TOPOLOGY_TRIANGLESTRIP); return true; }
bool Init_Device() { //Set up DX swap chain DXGI_SWAP_CHAIN_DESC swapChainDesc; ZeroMemory( &swapChainDesc, sizeof(swapChainDesc) ); //set buffer dimensions and format swapChainDesc.BufferCount = 2; swapChainDesc.BufferDesc.Width = GAME_RESOLUTION_X; swapChainDesc.BufferDesc.Height = GAME_RESOLUTION_Y; swapChainDesc.BufferUsage = DXGI_USAGE_RENDER_TARGET_OUTPUT; swapChainDesc.BufferDesc.Format = DXGI_FORMAT_R8G8B8A8_UNORM;; //set refresh rate swapChainDesc.BufferDesc.RefreshRate.Numerator = 60; swapChainDesc.BufferDesc.RefreshRate.Denominator = 1; //sampling settings swapChainDesc.SampleDesc.Quality = 0; swapChainDesc.SampleDesc.Count = 1; //output window handle swapChainDesc.OutputWindow = Window_GetHWND(); swapChainDesc.Windowed = !FULL_SCREEN; //Create the D3D device if ( FAILED( D3D10CreateDeviceAndSwapChain( NULL,D3D10_DRIVER_TYPE_HARDWARE,NULL,0,D3D10_SDK_VERSION,&swapChainDesc,&dx_swap_chain,&dx_device) ) ) return false; //try to get the back buffer ID3D10Texture2D* pBackBuffer; if ( FAILED( dx_swap_chain->GetBuffer(0, __uuidof(ID3D10Texture2D), (LPVOID*)&pBackBuffer) ) ) return false; //try to create render target view if ( FAILED( dx_device->CreateRenderTargetView(pBackBuffer, NULL, &dx_render_target) ) ) return false; //release the back buffer pBackBuffer->Release(); //set the render target dx_device->OMSetRenderTargets(1, &dx_render_target, NULL); //create viewport structure dx_viewport.Width = GAME_RESOLUTION_X; dx_viewport.Height = GAME_RESOLUTION_Y; dx_viewport.MinDepth = 0.0f; dx_viewport.MaxDepth = 1.0f; dx_viewport.TopLeftX = 0; dx_viewport.TopLeftY = 0; //set the viewport dx_device->RSSetViewports(1, &dx_viewport); //setup blend state D3D10_BLEND_DESC BlendState; ZeroMemory(&BlendState, sizeof(D3D10_BLEND_DESC)); BlendState.BlendEnable[0] = TRUE; BlendState.SrcBlend = D3D10_BLEND_SRC_ALPHA; BlendState.DestBlend = D3D10_BLEND_INV_SRC_ALPHA; BlendState.BlendOp = D3D10_BLEND_OP_ADD; BlendState.SrcBlendAlpha = D3D10_BLEND_ONE; BlendState.DestBlendAlpha = D3D10_BLEND_ONE; BlendState.BlendOpAlpha = D3D10_BLEND_OP_ADD; BlendState.RenderTargetWriteMask[0] = D3D10_COLOR_WRITE_ENABLE_ALL; dx_device->CreateBlendState(&BlendState, &dx_AlphaBlendState); //set blend state dx_device->OMSetBlendState(dx_AlphaBlendState, 0, 0xfffffff); return true; }