//======================================================================== // Initialize hardware for rendering. Member of AbstractRender //======================================================================== HRESULT DX10Render::initDevice() { UINT createDeviceFlags = 0; #ifdef _DEBUG createDeviceFlags |= D3D10_CREATE_DEVICE_DEBUG; #endif HRESULT hr = D3D10CreateDevice(NULL, D3D10_DRIVER_TYPE_HARDWARE, NULL, createDeviceFlags, D3D10_SDK_VERSION, &this->device); if (FAILED(hr)) return hr; DXGI_SWAP_CHAIN_DESC sd; ZeroMemory(&sd, sizeof(sd)); sd.BufferCount = 1; sd.BufferDesc.Width = this->resolution.width; sd.BufferDesc.Height = this->resolution.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 = this->hWindow; sd.SampleDesc.Count = 4; sd.SampleDesc.Quality = 4; sd.Windowed = !this->fullscreen; IDXGIFactory *factory = getDeviceFactory(device); if (factory == NULL) return E_FAIL; hr = factory->CreateSwapChain(device, &sd, &swapChain); if (FAILED(hr)) return hr; factory->Release(); return S_OK; }
//-------------------------------------------------------------------------------------- // Entry point to the program. Initializes everything and goes into a message processing // loop. Idle time is used to render the scene. //-------------------------------------------------------------------------------------- int _cdecl main( int NumArgs, char** ppCmdLine ) { // Enable run-time memory check for debug builds. #if defined(DEBUG) | defined(_DEBUG) _CrtSetDbgFlag( _CRTDBG_ALLOC_MEM_DF | _CRTDBG_LEAK_CHECK_DF ); #endif // This may fail if Direct3D 10 isn't installed WCHAR wszPath[MAX_PATH+1] = {0}; if( !::GetSystemDirectory( wszPath, MAX_PATH + 1 ) ) return false; wcscat_s( wszPath, MAX_PATH, L"\\d3d10.dll" ); HMODULE hMod = LoadLibrary( wszPath ); if( NULL == hMod ) { PrintError( "DirectX 10 is necessary to run GPUSpectrogram.\n" ); return 1; } FreeLibrary( hMod ); // parse the command line if( !ParseCommandLine( ppCmdLine, NumArgs ) ) return 1; // create a device HRESULT hr = S_OK; ID3D10Device* pDevice = NULL; DWORD dwCreateFlags = 0; #if defined(DEBUG) || defined(_DEBUG) dwCreateFlags |= D3D10_CREATE_DEVICE_DEBUG; #endif hr = D3D10CreateDevice( NULL, D3D10_DRIVER_TYPE_HARDWARE, ( HMODULE )0, dwCreateFlags, D3D10_SDK_VERSION, &pDevice ); if( FAILED( hr ) ) { hr = D3D10CreateDevice( NULL, D3D10_DRIVER_TYPE_REFERENCE, ( HMODULE )0, dwCreateFlags, D3D10_SDK_VERSION, &pDevice ); if( FAILED( hr ) ) { PrintError( "A suitable D3D10 device could not be created.\n" ); return 1; } } if( FAILED( InitResources( pDevice ) ) ) { PrintError( "GPUSpectrogram encountered an error creating resources.\n" ); return 2; } CreateSpectrogram( pDevice ); if( FAILED( SaveSpectogramToFile( pDevice, g_strBitmapName, g_pSourceTexture ) ) ) PrintError( "GPUSpectrogram encountered an error saving the spectrogram image file.\n" ); DestroyResources(); SAFE_RELEASE( pDevice ); return 0; }
static void test_create_device(void) { ID3D10Device *device; unsigned int i; HRESULT hr; if (FAILED(hr = D3D10CreateDevice(NULL, D3D10_DRIVER_TYPE_HARDWARE, NULL, 0, D3D10_SDK_VERSION, &device))) { skip("Failed to create HAL device.\n"); return; } ID3D10Device_Release(device); for (i = 0; i < 100; ++i) { if (i == D3D10_SDK_VERSION) continue; hr = D3D10CreateDevice(NULL, D3D10_DRIVER_TYPE_HARDWARE, NULL, 0, i, &device); ok(hr == E_INVALIDARG, "Got unexpected hr %#x for SDK version %#x.\n", hr, i); } }
static IDXGIDevice *create_device(void) { IDXGIDevice *dxgi_device; ID3D10Device *device; HRESULT hr; if (SUCCEEDED(D3D10CreateDevice(NULL, D3D10_DRIVER_TYPE_HARDWARE, NULL, 0, D3D10_SDK_VERSION, &device))) goto success; if (SUCCEEDED(D3D10CreateDevice(NULL, D3D10_DRIVER_TYPE_WARP, NULL, 0, D3D10_SDK_VERSION, &device))) goto success; if (SUCCEEDED(D3D10CreateDevice(NULL, D3D10_DRIVER_TYPE_REFERENCE, NULL, 0, D3D10_SDK_VERSION, &device))) goto success; return NULL; success: hr = ID3D10Device_QueryInterface(device, &IID_IDXGIDevice, (void **)&dxgi_device); ok(SUCCEEDED(hr), "Created device does not implement IDXGIDevice\n"); ID3D10Device_Release(device); return dxgi_device; }
void D3DApplication::InitDirect3D() { // Create the device. UINT createDeviceFlags = 0; #if defined(DEBUG) || defined(_DEBUG) createDeviceFlags |= D3D10_CREATE_DEVICE_DEBUG; #endif HR(D3D10CreateDevice(0, m_DriverType, 0, createDeviceFlags, D3D10_SDK_VERSION, &m_pDevice)); IDXGIFactory* pFactory; HR(CreateDXGIFactory(__uuidof(IDXGIFactory), (void**)(&pFactory))); // Fill out a DXGI_SWAP_CHAIN_DESC to describe our swap chain. DXGI_SWAP_CHAIN_DESC swapChainDescription; swapChainDescription.BufferDesc.Width = m_ClientWidth; swapChainDescription.BufferDesc.Height = m_ClientHeight; swapChainDescription.BufferDesc.RefreshRate.Numerator = 60; swapChainDescription.BufferDesc.RefreshRate.Denominator = 1; swapChainDescription.BufferDesc.Format = DXGI_FORMAT_R8G8B8A8_UNORM; swapChainDescription.BufferDesc.ScanlineOrdering = DXGI_MODE_SCANLINE_ORDER_UNSPECIFIED; swapChainDescription.BufferDesc.Scaling = DXGI_MODE_SCALING_UNSPECIFIED; // No multisampling. swapChainDescription.SampleDesc.Count = 1; swapChainDescription.SampleDesc.Quality = 0; swapChainDescription.BufferUsage = DXGI_USAGE_RENDER_TARGET_OUTPUT; swapChainDescription.BufferCount = 1; swapChainDescription.OutputWindow = m_hMainWindow; swapChainDescription.Windowed = true; swapChainDescription.SwapEffect = DXGI_SWAP_EFFECT_DISCARD; swapChainDescription.Flags = 0; HR(pFactory->CreateSwapChain(m_pDevice, &swapChainDescription, &m_pSwapChain)); HR(pFactory->MakeWindowAssociation(m_hMainWindow, DXGI_MWA_NO_WINDOW_CHANGES)); // 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(); }
HRESULT WINAPI D3D10CreateDeviceAndSwapChain(IDXGIAdapter *adapter, D3D10_DRIVER_TYPE driver_type, HMODULE swrast, UINT flags, UINT sdk_version, DXGI_SWAP_CHAIN_DESC *swapchain_desc, IDXGISwapChain **swapchain, ID3D10Device **device) { IDXGIDevice *dxgi_device; IDXGIFactory *factory; HRESULT hr; TRACE("adapter %p, driver_type %s, swrast %p, flags %#x, sdk_version %d,\n" "\tswapchain_desc %p, swapchain %p, device %p\n", adapter, debug_d3d10_driver_type(driver_type), swrast, flags, sdk_version, swapchain_desc, swapchain, device); hr = D3D10CreateDevice(adapter, driver_type, swrast, flags, sdk_version, device); if (FAILED(hr)) { WARN("Failed to create a device, returning %#x\n", hr); *device = NULL; return hr; } TRACE("Created ID3D10Device %p\n", *device); hr = ID3D10Device_QueryInterface(*device, &IID_IDXGIDevice, (void **)&dxgi_device); if (FAILED(hr)) { ERR("Failed to get a dxgi device from the d3d10 device, returning %#x\n", hr); ID3D10Device_Release(*device); *device = NULL; return hr; } hr = IDXGIDevice_GetAdapter(dxgi_device, &adapter); IDXGIDevice_Release(dxgi_device); if (FAILED(hr)) { ERR("Failed to get the device adapter, returning %#x\n", hr); ID3D10Device_Release(*device); *device = NULL; return hr; } hr = IDXGIAdapter_GetParent(adapter, &IID_IDXGIFactory, (void **)&factory); IDXGIAdapter_Release(adapter); if (FAILED(hr)) { ERR("Failed to get the adapter factory, returning %#x\n", hr); ID3D10Device_Release(*device); *device = NULL; return hr; } hr = IDXGIFactory_CreateSwapChain(factory, (IUnknown *)*device, swapchain_desc, swapchain); IDXGIFactory_Release(factory); if (FAILED(hr)) { ID3D10Device_Release(*device); *device = NULL; WARN("Failed to create a swapchain, returning %#x\n", hr); return hr; } TRACE("Created IDXGISwapChain %p\n", *swapchain); return S_OK; }
RenderDevice::RenderDevice(const RendererParams& p, HWND window) { RECT rc; GetClientRect(window, &rc); UINT width = rc.right - rc.left; UINT height = rc.bottom - rc.top; WindowWidth = width; WindowHeight = height; Window = window; Params = p; memset(UniformBuffers, 0, sizeof(UniformBuffers)); memset(CommonUniforms, 0, sizeof(CommonUniforms)); QuadVertexBuffer = NULL; HRESULT hr = CreateDXGIFactory(__uuidof(IDXGIFactory), (void**)(&DXGIFactory.GetRawRef())); if (FAILED(hr)) return; // Find the adapter & output (monitor) to use for fullscreen, based on the reported name of the HMD's monitor. if (Params.MonitorName.GetLength() > 0) { for(UINT AdapterIndex = 0; ; AdapterIndex++) { HRESULT hr = DXGIFactory->EnumAdapters(AdapterIndex, &Adapter.GetRawRef()); if (hr == DXGI_ERROR_NOT_FOUND) break; DXGI_ADAPTER_DESC Desc; Adapter->GetDesc(&Desc); UpdateMonitorOutputs(); if (FullscreenOutput) break; } if (!FullscreenOutput) Adapter = NULL; } if (!Adapter) { DXGIFactory->EnumAdapters(0, &Adapter.GetRawRef()); } int flags = 0; hr = D3D10CreateDevice(Adapter, D3D10_DRIVER_TYPE_HARDWARE, NULL, flags, D3D1x_(SDK_VERSION), &Device.GetRawRef()); Context = Device; Context->AddRef(); if (FAILED(hr)) return; if (!RecreateSwapChain()) return; if (Params.Fullscreen) SwapChain->SetFullscreenState(1, FullscreenOutput); CurRenderTarget = NULL; for(int i = 0; i < Shader_Count; i++) { UniformBuffers[i] = CreateBuffer(); MaxTextureSet[i] = 0; } ID3D10Blob* vsData = CompileShader("vs_4_0", DirectVertexShaderSrc); VertexShaders[VShader_MV] = *new VertexShader(this, vsData); for(int i = 1; i < VShader_Count; i++) { VertexShaders[i] = *new VertexShader(this, CompileShader("vs_4_0", VShaderSrcs[i])); } for(int i = 0; i < FShader_Count; i++) { PixelShaders[i] = *new PixelShader(this, CompileShader("ps_4_0", FShaderSrcs[i])); } SPInt bufferSize = vsData->GetBufferSize(); const void* buffer = vsData->GetBufferPointer(); ID3D1xInputLayout** objRef = &ModelVertexIL.GetRawRef(); HRESULT validate = Device->CreateInputLayout(ModelVertexDesc, sizeof(ModelVertexDesc)/sizeof(D3D1x_(INPUT_ELEMENT_DESC)), buffer, bufferSize, objRef); OVR_UNUSED(validate); Ptr<ShaderSet> gouraudShaders = *new ShaderSet(); gouraudShaders->SetShader(VertexShaders[VShader_MVP]); gouraudShaders->SetShader(PixelShaders[FShader_Gouraud]); DefaultFill = *new ShaderFill(gouraudShaders); D3D1x_(BLEND_DESC) bm; memset(&bm, 0, sizeof(bm)); bm.BlendEnable[0] = true; bm.BlendOp = bm.BlendOpAlpha = D3D1x_(BLEND_OP_ADD); bm.SrcBlend = bm.SrcBlendAlpha = D3D1x_(BLEND_SRC_ALPHA); bm.DestBlend = bm.DestBlendAlpha = D3D1x_(BLEND_INV_SRC_ALPHA); bm.RenderTargetWriteMask[0] = D3D1x_(COLOR_WRITE_ENABLE_ALL); Device->CreateBlendState(&bm, &BlendState.GetRawRef()); D3D1x_(RASTERIZER_DESC) rs; memset(&rs, 0, sizeof(rs)); rs.AntialiasedLineEnable = true; rs.CullMode = D3D1x_(CULL_BACK); rs.DepthClipEnable = true; rs.FillMode = D3D1x_(FILL_SOLID); Device->CreateRasterizerState(&rs, &Rasterizer.GetRawRef()); QuadVertexBuffer = CreateBuffer(); const RenderTiny::Vertex QuadVertices[] = { Vertex(Vector3f(0, 1, 0)), Vertex(Vector3f(1, 1, 0)), Vertex(Vector3f(0, 0, 0)), Vertex(Vector3f(1, 0, 0)) }; QuadVertexBuffer->Data(Buffer_Vertex, QuadVertices, sizeof(QuadVertices)); SetDepthMode(0, 0); }
int main(int argc, char *argv[]) { HRESULT hr; D3D10_USAGE Usage = D3D10_USAGE_DYNAMIC; for (int i = 1; i < argc; ++i) { const char *arg = argv[i]; if (strcmp(arg, "-dynamic") == 0) { Usage = D3D10_USAGE_DYNAMIC; } else if (strcmp(arg, "-staging") == 0) { Usage = D3D10_USAGE_STAGING; } else { fprintf(stderr, "error: unknown arg %s\n", arg); exit(1); } } com_ptr<IDXGIFactory> pFactory; hr = CreateDXGIFactory(IID_IDXGIFactory, (void**)&pFactory); if (FAILED(hr)) { return 1; } com_ptr<IDXGIAdapter> pAdapter; hr = pFactory->EnumAdapters(0, &pAdapter); if (FAILED(hr)) { return 1; } UINT Flags = 0; if (LoadLibraryA("d3d10sdklayers")) { Flags |= D3D10_CREATE_DEVICE_DEBUG; } com_ptr<ID3D10Device> pDevice; hr = D3D10CreateDevice(pAdapter, D3D10_DRIVER_TYPE_HARDWARE, NULL, Flags, D3D10_SDK_VERSION, &pDevice); if (FAILED(hr)) { return 1; } UINT NumBuffers = 4; UINT NumSegments = 8; UINT SegmentSize = 512; D3D10_BUFFER_DESC BufferDesc; ZeroMemory(&BufferDesc, sizeof BufferDesc); BufferDesc.ByteWidth = NumSegments * SegmentSize; BufferDesc.CPUAccessFlags = D3D10_CPU_ACCESS_WRITE; BufferDesc.MiscFlags = 0; BufferDesc.Usage = Usage; if (Usage == D3D10_USAGE_STAGING) { BufferDesc.BindFlags = 0; } else { BufferDesc.BindFlags = D3D10_BIND_VERTEX_BUFFER; } D3D10_MAP MapType = D3D10_MAP_WRITE; for (UINT i = 0; i < NumBuffers; ++i) { com_ptr<ID3D10Buffer> pVertexBuffer; hr = pDevice->CreateBuffer(&BufferDesc, NULL, &pVertexBuffer); if (FAILED(hr)) { return 1; } if (Usage == D3D10_USAGE_DYNAMIC) { MapType = D3D10_MAP_WRITE_DISCARD; } for (UINT j = 0; j < NumSegments; ++j) { BYTE *pMap = NULL; hr = pVertexBuffer->Map(MapType, 0, (void **)&pMap); if (FAILED(hr)) { return 1; } int c = (j % 255) + 1; memset(pMap + j*SegmentSize, c, SegmentSize); pVertexBuffer->Unmap(); if (Usage == D3D10_USAGE_DYNAMIC) { MapType = D3D10_MAP_WRITE_NO_OVERWRITE; } } pDevice->Flush(); D3D10_QUERY_DESC QueryDesc; QueryDesc.Query = D3D10_QUERY_EVENT; QueryDesc.MiscFlags = 0; com_ptr<ID3D10Query> pQuery; hr = pDevice->CreateQuery(&QueryDesc, &pQuery); if (FAILED(hr)) { return 1; } pQuery->End(); do { hr = pQuery->GetData(NULL, 0, 0); } while (hr == S_FALSE); if (FAILED(hr)) { return 1; } } return 0; }
void CD3D10Renderer::Init(HWND hWnd, bool bWindowed, int width, int height) { // D3D10 Device #ifdef _DEBUG HR(D3D10CreateDevice(0, D3D10_DRIVER_TYPE_HARDWARE, NULL, D3D10_CREATE_DEVICE_DEBUG, D3D10_SDK_VERSION, &m_pD3DDevice)); #else HR(D3D10CreateDevice(0, D3D10_DRIVER_TYPE_HARDWARE, NULL, 0, D3D10_SDK_VERSION, &m_pD3DDevice)); #endif // Used to create a swap chain separately CreateDXGIFactory(__uuidof(IDXGIFactory), (void**)(&m_pFactory) ); //CheckMultiSampleSupport(); // DXGI swap chain description (the "new" presentation params!) ZeroMemory(&m_swapDescription, sizeof(m_swapDescription)); m_swapDescription.BufferCount = 1; m_swapDescription.BufferDesc.Width = width; m_swapDescription.BufferDesc.Height = height; m_swapDescription.BufferDesc.Format = DXGI_FORMAT_R8G8B8A8_UNORM; m_swapDescription.BufferDesc.RefreshRate.Numerator = 60; m_swapDescription.BufferDesc.RefreshRate.Denominator = 1; m_swapDescription.BufferDesc.Scaling = DXGI_MODE_SCALING_UNSPECIFIED; m_swapDescription.BufferDesc.ScanlineOrdering = DXGI_MODE_SCANLINE_ORDER_UNSPECIFIED; m_swapDescription.BufferUsage = DXGI_USAGE_RENDER_TARGET_OUTPUT; m_swapDescription.Flags = DXGI_SWAP_CHAIN_FLAG_ALLOW_MODE_SWITCH; m_swapDescription.OutputWindow = hWnd; m_swapDescription.SampleDesc.Count = m_MSAA.Count; m_swapDescription.SampleDesc.Quality = m_MSAA.Quality; m_swapDescription.SwapEffect = DXGI_SWAP_EFFECT_DISCARD; m_swapDescription.Windowed = bWindowed; HR(m_pFactory->CreateSwapChain(m_pD3DDevice, &m_swapDescription, &m_pD3DSwapChain)); // Create D3D10 Device and Swap Chain //HR(D3D10CreateDeviceAndSwapChain( // 0, // Default device adapter // D3D10_DRIVER_TYPE_HARDWARE, // Device driver type // NULL, // No need for software rasterizer // D3D10_CREATE_DEVICE_DEBUG, // Debugging flags // D3D10_SDK_VERSION, // SDK Version // &m_swapDescription, // Swap chain description // &m_pD3DSwapChain, // Swap chain // &m_pD3DDevice)); // Returned D3D10 Device //if(!CheckMultiSampleSupport()) //{ // m_MSAA.Count = 1; // m_MSAA.Quality = 0; //} // Create Render Target View HR(m_pD3DSwapChain->GetBuffer(0, __uuidof(ID3D10Texture2D), reinterpret_cast<void**>(&m_pD3DBackbuffer))); HR(m_pD3DDevice->CreateRenderTargetView(m_pD3DBackbuffer, 0, &m_pD3DRenderTargetView)); m_pD3DBackbuffer->Release(); // Create the Depth/Stencil Buffer and View ZeroMemory(&m_D3DDepthStencilDesc, sizeof(m_D3DDepthStencilDesc)); m_D3DDepthStencilDesc.Width = width; m_D3DDepthStencilDesc.Height = height; m_D3DDepthStencilDesc.MipLevels = 1; m_D3DDepthStencilDesc.ArraySize = 1; m_D3DDepthStencilDesc.Format = DXGI_FORMAT_D24_UNORM_S8_UINT; m_D3DDepthStencilDesc.SampleDesc.Count = m_MSAA.Count; m_D3DDepthStencilDesc.SampleDesc.Quality = m_MSAA.Quality; m_D3DDepthStencilDesc.Usage = D3D10_USAGE_DEFAULT; m_D3DDepthStencilDesc.BindFlags = D3D10_BIND_DEPTH_STENCIL; m_D3DDepthStencilDesc.CPUAccessFlags = 0; m_D3DDepthStencilDesc.MiscFlags = 0; // Bind Depth/Stencil buffer resource to pipeline HR(m_pD3DDevice->CreateTexture2D(&m_D3DDepthStencilDesc, 0, &m_pDepthStencilBuffer)); HR(m_pD3DDevice->CreateDepthStencilView(m_pDepthStencilBuffer, 0, &m_pDepthStencilView)); // Bind views to output merger stage m_pD3DDevice->OMSetRenderTargets(1, &m_pD3DRenderTargetView, m_pDepthStencilView); // Set up view port m_D3DViewport.TopLeftX = 0; m_D3DViewport.TopLeftY = 0; m_D3DViewport.Width = width; m_D3DViewport.Height = height; m_D3DViewport.MinDepth = 0.0f; m_D3DViewport.MaxDepth = 1.0f; m_pD3DDevice->RSSetViewports(1, &m_D3DViewport); }
//D3D10CreateDeviceAndSwapChain extern "C" _declspec(dllexport) HRESULT WINAPI newD3D10CreateDeviceAndSwapChain(IDXGIAdapter *adapter, D3D10_DRIVER_TYPE DriverType, HMODULE Software, UINT Flags, UINT SDKVersion, DXGI_SWAP_CHAIN_DESC *pSwapChainDesc, IDXGISwapChain **ppSwapChain, ID3D10Device **ppDevice) { dbg("d3d10: D3D10CreateDeviceAndSwapChain 0x%08X 0x%08X", adapter, *adapter); /*dbg("Mode: %dx%d %d.%dHz %s", pSwapChainDesc->BufferDesc.Width, pSwapChainDesc->BufferDesc.Height, pSwapChainDesc->BufferDesc.RefreshRate.Numerator, pSwapChainDesc->BufferDesc.RefreshRate.Denominator, pSwapChainDesc->Windowed?"Windowed":"Fullscreen"); dbg("Multisample: %d samples, quality %d", pSwapChainDesc->SampleDesc.Count, pSwapChainDesc->SampleDesc.Quality); dbg("Buffers: %d (Usage %s), Swapeffect: %s", pSwapChainDesc->BufferCount, getUsageDXGI(pSwapChainDesc->BufferUsage), pSwapChainDesc->SwapEffect==DXGI_SWAP_EFFECT_DISCARD?"DISCARD":"SEQUENTIAL"); dbg("Flags: %s %s %s", pSwapChainDesc->Flags&DXGI_SWAP_CHAIN_FLAG_NONPREROTATED?"NONPREROTATED":"", pSwapChainDesc->Flags&DXGI_SWAP_CHAIN_FLAG_ALLOW_MODE_SWITCH?"ALLOW_MODE_SWITCH":"", pSwapChainDesc->Flags&DXGI_SWAP_CHAIN_FLAG_GDI_COMPATIBLE?"GDI_COMPATIBLE":"");*/ HRESULT ret; /*ret = D3D10CreateDevice(adapter, D3D10_DRIVER_TYPE_HARDWARE, NULL, 0, D3D10_SDK_VERSION, ppDevice );*/ ret = D3D10CreateDevice(adapter, DriverType, Software, Flags, SDKVersion, ppDevice ); /*IDXGIAdapter1New *anew; if(adapter->QueryInterface(IID_IDXGIAdapter, (void**) &anew) == S_OK) { adapter = anew->getReal(); anew->Release(); }*/ IDXGIFactory1 *factory; //IDXGIFactory1New *fnew; //CreateDXGIFactory1() if(adapter->GetParent(IID_IDXGIFactory, (void**) &factory) == S_OK) { //factory = fnew->getReal(); //fnew->Release(); dbg("d3d10: Got parent factory"); } //ret = dllD3D10CreateDeviceAndSwapChain(anew, DriverType, Software, Flags, SDKVersion, pSwapChainDesc, ppSwapChain, ppDevice); (*ppSwapChain) = new IDXGISwapChainNew(factory, factory, *ppDevice, pSwapChainDesc); /*IDXGISwapChainNew *scnew; if((*ppSwapChain)->QueryInterface(IID_IDXGISwapChainNew, (void**) &scnew) == S_OK) { (*ppSwapChain) = scnew->getReal(); scnew->Release(); } else dbg("Booh! No real swap chain!");*/ /*if(fnew) { fnew->Release(); delete fnew; fnew = NULL; }*/ return ret; }
bool D3D10App::initAPI(const DXGI_FORMAT backBufferFmt, const DXGI_FORMAT depthBufferFmt, const int samples, const uint flags){ backBufferFormat = backBufferFmt; depthBufferFormat = depthBufferFmt; msaaSamples = samples; // if (screen >= GetSystemMetrics(SM_CMONITORS)) screen = 0; IDXGIFactory *dxgiFactory; if (FAILED(CreateDXGIFactory(__uuidof(IDXGIFactory), (void **) &dxgiFactory))){ ErrorMsg("Couldn't create DXGIFactory"); return false; } IDXGIAdapter *dxgiAdapter; if (dxgiFactory->EnumAdapters(0, &dxgiAdapter) == DXGI_ERROR_NOT_FOUND){ ErrorMsg("No adapters found"); return false; } // DXGI_ADAPTER_DESC adapterDesc; // dxgiAdapter->GetDesc(&adapterDesc); IDXGIOutput *dxgiOutput; if (dxgiAdapter->EnumOutputs(0, &dxgiOutput) == DXGI_ERROR_NOT_FOUND){ ErrorMsg("No outputs found"); return false; } DXGI_OUTPUT_DESC oDesc; dxgiOutput->GetDesc(&oDesc); // Find a suitable fullscreen format int targetHz = 85; DXGI_RATIONAL fullScreenRefresh; int fsRefresh = 60; fullScreenRefresh.Numerator = fsRefresh; fullScreenRefresh.Denominator = 1; char str[128]; uint nModes = 0; dxgiOutput->GetDisplayModeList(backBufferFormat, 0, &nModes, NULL); DXGI_MODE_DESC *modes = new DXGI_MODE_DESC[nModes]; dxgiOutput->GetDisplayModeList(backBufferFormat, 0, &nModes, modes); resolution->clear(); for (uint i = 0; i < nModes; i++){ if (modes[i].Width >= 640 && modes[i].Height >= 480){ sprintf(str, "%dx%d", modes[i].Width, modes[i].Height); int index = resolution->addItemUnique(str); if (int(modes[i].Width) == fullscreenWidth && int(modes[i].Height) == fullscreenHeight){ int refresh = modes[i].RefreshRate.Numerator / modes[i].RefreshRate.Denominator; if (abs(refresh - targetHz) < abs(fsRefresh - targetHz)){ fsRefresh = refresh; fullScreenRefresh = modes[i].RefreshRate; } resolution->selectItem(index); } } } delete modes; sprintf(str, "%s (%dx%d)", getTitle(), width, height); DWORD wndFlags = 0; int x, y, w, h; if (fullscreen){ wndFlags |= WS_POPUP; x = y = 0; w = width; h = height; } else { wndFlags |= WS_OVERLAPPEDWINDOW; RECT wRect; wRect.left = 0; wRect.right = width; wRect.top = 0; wRect.bottom = height; AdjustWindowRect(&wRect, wndFlags, FALSE); MONITORINFO monInfo; monInfo.cbSize = sizeof(monInfo); GetMonitorInfo(oDesc.Monitor, &monInfo); w = min(wRect.right - wRect.left, monInfo.rcWork.right - monInfo.rcWork.left); h = min(wRect.bottom - wRect.top, monInfo.rcWork.bottom - monInfo.rcWork.top); x = (monInfo.rcWork.left + monInfo.rcWork.right - w) / 2; y = (monInfo.rcWork.top + monInfo.rcWork.bottom - h) / 2; } hwnd = CreateWindow("Humus", str, wndFlags, x, y, w, h, HWND_DESKTOP, NULL, hInstance, NULL); RECT rect; GetClientRect(hwnd, &rect); // Create device and swap chain DXGI_SWAP_CHAIN_DESC sd; memset(&sd, 0, sizeof(sd)); sd.BufferDesc.Width = rect.right; sd.BufferDesc.Height = rect.bottom; sd.BufferDesc.Format = backBufferFormat; sd.BufferDesc.RefreshRate = fullScreenRefresh; sd.BufferUsage = DXGI_USAGE_RENDER_TARGET_OUTPUT; sd.BufferCount = 1; sd.OutputWindow = hwnd; sd.Windowed = (BOOL) (!fullscreen); sd.SwapEffect = DXGI_SWAP_EFFECT_DISCARD; sd.Flags = DXGI_SWAP_CHAIN_FLAG_ALLOW_MODE_SWITCH; DWORD deviceFlags = D3D10_CREATE_DEVICE_SINGLETHREADED; #ifdef _DEBUG deviceFlags |= D3D10_CREATE_DEVICE_DEBUG; #endif if (FAILED(D3D10CreateDevice(dxgiAdapter, D3D10_DRIVER_TYPE_HARDWARE, NULL, deviceFlags, D3D10_SDK_VERSION, &device))){ ErrorMsg("Couldn't create D3D10 device"); return false; } while (msaaSamples > 0){ UINT nQuality; if (SUCCEEDED(device->CheckMultisampleQualityLevels(backBufferFormat, msaaSamples, &nQuality)) && nQuality > 0){ if ((flags & NO_SETTING_CHANGE) == 0) antiAliasSamples = msaaSamples; break; } else { msaaSamples -= 2; } } sd.SampleDesc.Count = msaaSamples; sd.SampleDesc.Quality = 0; if (FAILED(dxgiFactory->CreateSwapChain(device, &sd, &swapChain))){ ErrorMsg("Couldn't create swapchain"); return false; } // We'll handle Alt-Enter ourselves thank you very much ... dxgiFactory->MakeWindowAssociation(hwnd, DXGI_MWA_NO_WINDOW_CHANGES | DXGI_MWA_NO_ALT_ENTER); dxgiOutput->Release(); dxgiAdapter->Release(); dxgiFactory->Release(); if (!createBuffers()) return false; if (fullscreen){ captureMouse(!configDialog->isVisible()); } renderer = new Direct3D10Renderer(device); ((Direct3D10Renderer *) renderer)->setFrameBuffer(backBufferRTV, depthBufferDSV); antiAlias->selectItem(antiAliasSamples / 2); linearClamp = renderer->addSamplerState(LINEAR, CLAMP, CLAMP, CLAMP); defaultFont = renderer->addFont("../Textures/Fonts/Future.dds", "../Textures/Fonts/Future.font", linearClamp); blendSrcAlpha = renderer->addBlendState(SRC_ALPHA, ONE_MINUS_SRC_ALPHA); noDepthTest = renderer->addDepthState(false, false); noDepthWrite = renderer->addDepthState(true, false); cullNone = renderer->addRasterizerState(CULL_NONE); cullBack = renderer->addRasterizerState(CULL_BACK); cullFront = renderer->addRasterizerState(CULL_FRONT); return true; }