void BBWin8Game::CreateD3dDevice(){
CoreWindow ^window=CoreWindow::GetForCurrentThread();
int width=DipsToPixels( window->Bounds.Width );
int height=DipsToPixels( window->Bounds.Height );
#if WINDOWS_8
switch( DisplayProperties::CurrentOrientation ){
case DisplayOrientations::Portrait:
case DisplayOrientations::PortraitFlipped:
std::swap( width,height );
break;
}
#endif
UINT creationFlags=D3D11_CREATE_DEVICE_BGRA_SUPPORT;
#ifdef _DEBUG
creationFlags|=D3D11_CREATE_DEVICE_DEBUG;
#endif
#if WINDOWS_8
D3D_FEATURE_LEVEL featureLevels[]={
D3D_FEATURE_LEVEL_11_1,
D3D_FEATURE_LEVEL_11_0,
D3D_FEATURE_LEVEL_10_1,
D3D_FEATURE_LEVEL_10_0,
D3D_FEATURE_LEVEL_9_3,
D3D_FEATURE_LEVEL_9_2,
D3D_FEATURE_LEVEL_9_1
};
#elif WINDOWS_PHONE_8
D3D_FEATURE_LEVEL featureLevels[]={
D3D_FEATURE_LEVEL_11_1,
D3D_FEATURE_LEVEL_11_0,
D3D_FEATURE_LEVEL_10_1,
D3D_FEATURE_LEVEL_10_0,
D3D_FEATURE_LEVEL_9_3
};
#endif
ID3D11Device *device;
ID3D11DeviceContext *context;
DXASS( D3D11CreateDevice(
0,
D3D_DRIVER_TYPE_HARDWARE,
0,
creationFlags,
featureLevels,
ARRAYSIZE(featureLevels),
D3D11_SDK_VERSION,
&device,
&_featureLevel,
&context ) );
DXASS( device->QueryInterface( __uuidof( ID3D11Device1 ),(void**)&_d3dDevice ) );
DXASS( context->QueryInterface( __uuidof( ID3D11DeviceContext1 ),(void**)&_d3dContext ) );
device->Release();
context->Release();
//create swap chain
if( _swapChain ){
DXASS( _swapChain->ResizeBuffers( 2,width,height,DXGI_FORMAT_B8G8R8A8_UNORM,0 ) );
}else{
#if WINDOWS_8
DXGI_SWAP_CHAIN_DESC1 swapChainDesc={0};
swapChainDesc.Width=width;
swapChainDesc.Height=height;
swapChainDesc.Format=DXGI_FORMAT_B8G8R8A8_UNORM;
swapChainDesc.Stereo=false;
swapChainDesc.SampleDesc.Count=1;
swapChainDesc.SampleDesc.Quality=0;
swapChainDesc.BufferUsage=DXGI_USAGE_RENDER_TARGET_OUTPUT;
swapChainDesc.BufferCount=2;
swapChainDesc.Scaling=DXGI_SCALING_NONE;
swapChainDesc.SwapEffect=DXGI_SWAP_EFFECT_FLIP_SEQUENTIAL;
swapChainDesc.Flags=0;
#elif WINDOWS_PHONE_8
DXGI_SWAP_CHAIN_DESC1 swapChainDesc={0};
swapChainDesc.Width=width;
swapChainDesc.Height=height;
swapChainDesc.Format=DXGI_FORMAT_B8G8R8A8_UNORM;
swapChainDesc.Stereo=false;
swapChainDesc.SampleDesc.Count=1;
swapChainDesc.SampleDesc.Quality=0;
swapChainDesc.BufferUsage=DXGI_USAGE_RENDER_TARGET_OUTPUT;
swapChainDesc.BufferCount=1;
swapChainDesc.Scaling=DXGI_SCALING_STRETCH;
swapChainDesc.SwapEffect=DXGI_SWAP_EFFECT_DISCARD;
swapChainDesc.Flags=0;
#endif
IDXGIDevice1 *dxgiDevice;
DXASS( _d3dDevice->QueryInterface( __uuidof( IDXGIDevice1 ),(void**)&dxgiDevice ) );
IDXGIAdapter *dxgiAdapter;
DXASS( dxgiDevice->GetAdapter( &dxgiAdapter ) );
IDXGIFactory2 *dxgiFactory;
DXASS( dxgiAdapter->GetParent( __uuidof( IDXGIFactory2 ),(void**)&dxgiFactory ) );
DXASS( dxgiFactory->CreateSwapChainForCoreWindow( _d3dDevice,(IUnknown*)window,&swapChainDesc,0,&_swapChain ) );
DXASS( dxgiDevice->SetMaximumFrameLatency( 1 ) );
dxgiFactory->Release();
dxgiAdapter->Release();
dxgiDevice->Release();
}
// Create a render target view of the swap chain back buffer.
//
ID3D11Texture2D *backBuffer;
DXASS( _swapChain->GetBuffer( 0,__uuidof( ID3D11Texture2D ),(void**)&backBuffer ) );
DXASS( _d3dDevice->CreateRenderTargetView( backBuffer,0,&_renderTargetView ) );
backBuffer->Release();
/*
// Create a depth stencil view
//
D3D11_TEXTURE2D_DESC dsdesc;
ZEROMEM( dsdesc );
dsdesc.Width=width;
dsdesc.Height=height;
dsdesc.MipLevels=1;
dsdesc.ArraySize=1;
dsdesc.Format=DXGI_FORMAT_D24_UNORM_S8_UINT;
dsdesc.SampleDesc.Count=1;
dsdesc.SampleDesc.Quality=0;
dsdesc.Usage=D3D11_USAGE_DEFAULT;
dsdesc.BindFlags=D3D11_BIND_DEPTH_STENCIL;
dsdesc.CpuAccessFlags=0;
dsdesc.MiscFlags=0;
ID3D11Texture2D *depthStencil;
DXASS( _d3dDevice->CreateTexture2D( &dsdesc,0,&depthStencil ) );
DXASS( _d3dDevice->CreateDepthStencilView( depthStencil,0,&_depthStencilView ) );
depthStencil->Release();
*/
D3D11_VIEWPORT viewport={ 0,0,width,height,0,1 };
_d3dContext->RSSetViewports( 1,&viewport );
}
//--------------------------------------------------------------------------------------
HRESULT CD3D11Enumeration::EnumerateDevices( _In_ CD3D11EnumAdapterInfo* pAdapterInfo )
{
HRESULT hr;
DXUTDeviceSettings deviceSettings = DXUTGetDeviceSettings();
const D3D_DRIVER_TYPE devTypeArray[] =
{
D3D_DRIVER_TYPE_HARDWARE,
D3D_DRIVER_TYPE_WARP,
D3D_DRIVER_TYPE_REFERENCE
};
const UINT devTypeArrayCount = sizeof( devTypeArray ) / sizeof( devTypeArray[0] );
// Enumerate each Direct3D device type
for( UINT iDeviceType = 0; iDeviceType < devTypeArrayCount; iDeviceType++ )
{
CD3D11EnumDeviceInfo* pDeviceInfo = new (std::nothrow) CD3D11EnumDeviceInfo;
if( !pDeviceInfo )
return E_OUTOFMEMORY;
// Fill struct w/ AdapterOrdinal and D3D_DRIVER_TYPE
pDeviceInfo->AdapterOrdinal = pAdapterInfo->AdapterOrdinal;
pDeviceInfo->DeviceType = devTypeArray[iDeviceType];
D3D_FEATURE_LEVEL FeatureLevels[] =
{
D3D_FEATURE_LEVEL_11_1,
D3D_FEATURE_LEVEL_11_0,
D3D_FEATURE_LEVEL_10_1,
D3D_FEATURE_LEVEL_10_0,
D3D_FEATURE_LEVEL_9_3,
D3D_FEATURE_LEVEL_9_2,
D3D_FEATURE_LEVEL_9_1
};
UINT NumFeatureLevels = ARRAYSIZE( FeatureLevels );
// Call D3D11CreateDevice to ensure that this is a D3D11 device.
ID3D11Device* pd3dDevice = nullptr;
ID3D11DeviceContext* pd3dDeviceContext = nullptr;
IDXGIAdapter* pAdapter = nullptr;
hr = DXUT_Dynamic_D3D11CreateDevice( pAdapter,
devTypeArray[iDeviceType],
( HMODULE )0,
0,
FeatureLevels,
NumFeatureLevels,
D3D11_SDK_VERSION,
&pd3dDevice,
&pDeviceInfo->MaxLevel,
&pd3dDeviceContext );
if ( hr == E_INVALIDARG )
{
// DirectX 11.0 runtime will not recognize FL 11.1, so try without it
hr = DXUT_Dynamic_D3D11CreateDevice( pAdapter,
devTypeArray[iDeviceType],
( HMODULE )0,
0,
&FeatureLevels[1],
NumFeatureLevels - 1,
D3D11_SDK_VERSION,
&pd3dDevice,
&pDeviceInfo->MaxLevel,
&pd3dDeviceContext );
}
if( FAILED( hr ) || pDeviceInfo->MaxLevel < deviceSettings.MinimumFeatureLevel)
{
delete pDeviceInfo;
continue;
}
if (m_forceFL == 0 || m_forceFL == pDeviceInfo->MaxLevel)
{
pDeviceInfo->SelectedLevel = pDeviceInfo->MaxLevel;
}
else if (m_forceFL > pDeviceInfo->MaxLevel)
{
delete pDeviceInfo;
SAFE_RELEASE( pd3dDevice );
SAFE_RELEASE( pd3dDeviceContext );
continue;
}
else
{
// A device was created with a higher feature level that the user-specified feature level.
SAFE_RELEASE( pd3dDevice );
SAFE_RELEASE( pd3dDeviceContext );
D3D_FEATURE_LEVEL rtFL;
hr = DXUT_Dynamic_D3D11CreateDevice( pAdapter,
devTypeArray[iDeviceType],
( HMODULE )0,
0,
&m_forceFL,
1,
D3D11_SDK_VERSION,
&pd3dDevice,
&rtFL,
&pd3dDeviceContext );
if( SUCCEEDED( hr ) && rtFL == m_forceFL )
{
pDeviceInfo->SelectedLevel = m_forceFL;
}
else
{
delete pDeviceInfo;
if ( SUCCEEDED(hr) )
{
SAFE_RELEASE( pd3dDevice );
SAFE_RELEASE( pd3dDeviceContext );
}
continue;
}
}
IDXGIDevice1* pDXGIDev = nullptr;
hr = pd3dDevice->QueryInterface( __uuidof( IDXGIDevice1 ), ( LPVOID* )&pDXGIDev );
if( SUCCEEDED( hr ) && pDXGIDev )
{
SAFE_RELEASE( pAdapterInfo->m_pAdapter );
pDXGIDev->GetAdapter( &pAdapterInfo->m_pAdapter );
}
SAFE_RELEASE( pDXGIDev );
D3D11_FEATURE_DATA_D3D10_X_HARDWARE_OPTIONS ho;
hr = pd3dDevice->CheckFeatureSupport(D3D11_FEATURE_D3D10_X_HARDWARE_OPTIONS, &ho, sizeof(ho));
if ( FAILED(hr) )
memset( &ho, 0, sizeof(ho) );
pDeviceInfo->ComputeShaders_Plus_RawAndStructuredBuffers_Via_Shader_4_x = ho.ComputeShaders_Plus_RawAndStructuredBuffers_Via_Shader_4_x;
SAFE_RELEASE( pd3dDeviceContext );
SAFE_RELEASE( pd3dDevice );
pAdapterInfo->deviceInfoList.push_back( pDeviceInfo );
}
return S_OK;
}
int ContextD3D11::CreateWindowSizeDependentResources(uint32_t width, uint32_t height) {
ID3D11RenderTargetView* nullViews[] = {nullptr};
device_context_->OMSetRenderTargets(ARRAYSIZE(nullViews), nullViews, nullptr);
SafeRelease(&render_target_view_);
SafeRelease(&depth_stencil_view_);
device_context_->Flush();
//RECT rc;
//GetClientRect( window_handle_, &rc );
width_ = width;//rc.right - rc.left;
height_ = height;//rc.bottom - rc.top;
if(swap_chain_ != nullptr)
{
swap_chain_->ResizeBuffers(2, static_cast<UINT>(width_),static_cast<UINT>(height_), DXGI_FORMAT_B8G8R8A8_UNORM, 0);
}
else
{
// Otherwise, create a new one using the same adapter as the existing Direct3D device.
DXGI_SWAP_CHAIN_DESC1 swapChainDesc = {0};
swapChainDesc.Width = static_cast<UINT>(width_); // Match the size of the window.
swapChainDesc.Height = static_cast<UINT>(height_);
swapChainDesc.Format = DXGI_FORMAT_B8G8R8A8_UNORM; // This is the most common swap chain format.
swapChainDesc.Stereo = false;
swapChainDesc.SampleDesc.Count = 1; // Don't use multi-sampling.
swapChainDesc.SampleDesc.Quality = 0;
swapChainDesc.BufferUsage = DXGI_USAGE_RENDER_TARGET_OUTPUT;
swapChainDesc.BufferCount = 2; // Use double-buffering to minimize latency.
swapChainDesc.Scaling = DXGI_SCALING_NONE;
swapChainDesc.SwapEffect = DXGI_SWAP_EFFECT_FLIP_SEQUENTIAL; // All Windows Store apps must use this SwapEffect.
swapChainDesc.Flags = DXGI_SWAP_CHAIN_FLAG_ALLOW_MODE_SWITCH;
IDXGIDevice1* dxgiDevice;
device_->QueryInterface(__uuidof(dxgiDevice),(void**)&dxgiDevice);
//IDXGIAdapter* dxgiAdapter;
//dxgiDevice->GetAdapter(&dxgiAdapter);
IDXGIFactory2* dxgiFactory;
adaptor_->GetParent(__uuidof(IDXGIFactory2), (void**)&dxgiFactory );
DXGI_SWAP_CHAIN_FULLSCREEN_DESC fullscreen_desc;
memset(&fullscreen_desc,0,sizeof(fullscreen_desc));
fullscreen_desc.Windowed = true;
dxgiFactory->CreateSwapChainForHwnd(device_,window_handle_, &swapChainDesc, &fullscreen_desc,nullptr, &swap_chain_);
dxgiDevice->SetMaximumFrameLatency(1);
SafeRelease(&dxgiFactory);
//SafeRelease(&dxgiAdapter);
SafeRelease(&dxgiDevice);
}
ID3D11Texture2D* backBuffer;
swap_chain_->GetBuffer(0,__uuidof(ID3D11Texture2D),(void**)&backBuffer);
device_->CreateRenderTargetView(backBuffer,nullptr,&render_target_view_);
SafeRelease(&backBuffer);
// Create a depth stencil view.
CD3D11_TEXTURE2D_DESC depthStencilTextureDesc(
DXGI_FORMAT_D24_UNORM_S8_UINT,
static_cast<UINT>(width_),
static_cast<UINT>(height_),
1,
0,
D3D11_BIND_DEPTH_STENCIL
);
ID3D11Texture2D* depth_stencil_tex;
device_->CreateTexture2D(&depthStencilTextureDesc,nullptr,&depth_stencil_tex);
CD3D11_DEPTH_STENCIL_VIEW_DESC depthStencilViewDesc(D3D11_DSV_DIMENSION_TEXTURE2D);
device_->CreateDepthStencilView(depth_stencil_tex,&depthStencilViewDesc,&depth_stencil_view_);
SafeRelease(&depth_stencil_tex);
SafeRelease(&default_depth_state);
D3D11_DEPTH_STENCIL_DESC depthStencilDesc;
// Initialize the description of the stencil state.
ZeroMemory(&depthStencilDesc, sizeof(depthStencilDesc));
depthStencilDesc.DepthEnable = true;
depthStencilDesc.DepthWriteMask = D3D11_DEPTH_WRITE_MASK_ALL;
depthStencilDesc.DepthFunc = D3D11_COMPARISON_LESS;
depthStencilDesc.StencilEnable = true;
depthStencilDesc.StencilReadMask = D3D11_DEFAULT_STENCIL_READ_MASK;
depthStencilDesc.StencilWriteMask = 0xFF;
// Stencil operations if pixel is front-facing.
depthStencilDesc.FrontFace.StencilFailOp = D3D11_STENCIL_OP_KEEP;
depthStencilDesc.FrontFace.StencilDepthFailOp = D3D11_STENCIL_OP_INCR;
depthStencilDesc.FrontFace.StencilPassOp = D3D11_STENCIL_OP_KEEP;
depthStencilDesc.FrontFace.StencilFunc = D3D11_COMPARISON_ALWAYS;
// Stencil operations if pixel is back-facing.
depthStencilDesc.BackFace.StencilFailOp = D3D11_STENCIL_OP_KEEP;
depthStencilDesc.BackFace.StencilDepthFailOp = D3D11_STENCIL_OP_DECR;
depthStencilDesc.BackFace.StencilPassOp = D3D11_STENCIL_OP_KEEP;
depthStencilDesc.BackFace.StencilFunc = D3D11_COMPARISON_ALWAYS;
device_->CreateDepthStencilState(&depthStencilDesc, &default_depth_state);
SetDepthState(null,0);
// Set the rendering viewport to target the entire window.
CD3D11_VIEWPORT viewport(0.0f,0.0f,width_,height_);
device_context_->RSSetViewports(1, &viewport);
device_context_->OMSetRenderTargets( 1, &render_target_view_, depth_stencil_view_ );
return S_OK;
}
void Graphics4::init(int windowId, int depthBufferBits, int stencilBufferBits, bool vSync) {
#ifdef KORE_VR
vsync = false;
#else
vsync = vSync;
#endif
for (int i = 0; i < 1024 * 4; ++i) vertexConstants[i] = 0;
for (int i = 0; i < 1024 * 4; ++i) fragmentConstants[i] = 0;
#ifdef KORE_WINDOWS
HWND hwnd = Window::get(windowId)->_data.handle;
#endif
UINT creationFlags = D3D11_CREATE_DEVICE_BGRA_SUPPORT;
#ifdef _DEBUG
creationFlags |= D3D11_CREATE_DEVICE_DEBUG;
#endif
D3D_FEATURE_LEVEL featureLevels[] = {
#ifdef KORE_WINDOWSAPP
D3D_FEATURE_LEVEL_11_1,
#endif
D3D_FEATURE_LEVEL_11_0, D3D_FEATURE_LEVEL_10_1, D3D_FEATURE_LEVEL_10_0};
#ifdef KORE_WINDOWSAPP
IDXGIAdapter3* adapter = nullptr;
#ifdef KORE_HOLOLENS
adapter = holographicFrameController->getCompatibleDxgiAdapter().Get();
#endif
Kore_Microsoft_affirm(D3D11CreateDevice(adapter, D3D_DRIVER_TYPE_HARDWARE, nullptr, creationFlags, featureLevels, ARRAYSIZE(featureLevels), D3D11_SDK_VERSION,
&device, &featureLevel, &context));
#elif KORE_OCULUS
IDXGIFactory* dxgiFactory = nullptr;
Windows::affirm(CreateDXGIFactory1(__uuidof(IDXGIFactory), (void**)(&dxgiFactory)));
Windows::affirm(D3D11CreateDevice(nullptr, D3D_DRIVER_TYPE_HARDWARE, 0, creationFlags, featureLevels, ARRAYSIZE(featureLevels), D3D11_SDK_VERSION, &device,
&featureLevel, &context));
#endif
// affirm(device0.As(&device));
// affirm(context0.As(&context));
// m_windowBounds = m_window->Bounds;
const int _DXGI_SWAP_EFFECT_FLIP_SEQUENTIAL = 3;
const int _DXGI_SWAP_EFFECT_FLIP_DISCARD = 4;
if (swapChain != nullptr) {
Kore_Microsoft_affirm(swapChain->ResizeBuffers(2, 0, 0, DXGI_FORMAT_B8G8R8A8_UNORM, 0));
}
else {
#ifdef KORE_WINDOWS
DXGI_SWAP_CHAIN_DESC swapChainDesc = {0};
swapChainDesc.BufferUsage = DXGI_USAGE_RENDER_TARGET_OUTPUT;
swapChainDesc.BufferDesc.RefreshRate.Denominator = 1; // 60Hz
swapChainDesc.BufferDesc.RefreshRate.Numerator = 60;
swapChainDesc.BufferDesc.Width = System::windowWidth(windowId); // use automatic sizing
swapChainDesc.BufferDesc.Height = System::windowHeight(windowId);
swapChainDesc.BufferDesc.Format = DXGI_FORMAT_B8G8R8A8_UNORM; // this is the most common swapchain format
// swapChainDesc.Stereo = false;
swapChainDesc.SampleDesc.Count = antialiasingSamples() > 1 ? antialiasingSamples() : 1;
swapChainDesc.SampleDesc.Quality = antialiasingSamples() > 1 ? D3D11_STANDARD_MULTISAMPLE_PATTERN : 0;
swapChainDesc.BufferUsage = DXGI_USAGE_RENDER_TARGET_OUTPUT;
swapChainDesc.BufferCount = 2; // use two buffers to enable flip effect
swapChainDesc.BufferDesc.ScanlineOrdering = DXGI_MODE_SCANLINE_ORDER_UNSPECIFIED;
swapChainDesc.BufferDesc.Scaling = DXGI_MODE_SCALING_UNSPECIFIED; // DXGI_SCALING_NONE;
if (isWindows10OrGreater()) {
swapChainDesc.SwapEffect = DXGI_SWAP_EFFECT_DISCARD;
//(DXGI_SWAP_EFFECT) _DXGI_SWAP_EFFECT_FLIP_DISCARD;
}
else if (isWindows8OrGreater()) {
swapChainDesc.SwapEffect = DXGI_SWAP_EFFECT_DISCARD;
//(DXGI_SWAP_EFFECT) _DXGI_SWAP_EFFECT_FLIP_SEQUENTIAL;
}
else {
swapChainDesc.SwapEffect = DXGI_SWAP_EFFECT_DISCARD;
}
swapChainDesc.Flags = 0;
swapChainDesc.OutputWindow = Window::get(windowId)->_data.handle;
swapChainDesc.Windowed = true;
#endif
#if defined(KORE_WINDOWSAPP)
#ifdef KORE_HOLOLENS
// The Windows::Graphics::Holographic::HolographicSpace owns its own swapchain so we don't need to create one here
#else
DXGI_SWAP_CHAIN_DESC1 swapChainDesc = {0};
swapChainDesc.Width = 0; // use automatic sizing
swapChainDesc.Height = 0;
swapChainDesc.Format = DXGI_FORMAT_B8G8R8A8_UNORM; // this is the most common swapchain format
swapChainDesc.Stereo = false;
swapChainDesc.SampleDesc.Count = antialiasingSamples() > 1 ? antialiasingSamples() : 1;
swapChainDesc.SampleDesc.Quality = antialiasingSamples() > 1 ? D3D11_STANDARD_MULTISAMPLE_PATTERN : 0;
swapChainDesc.BufferUsage = DXGI_USAGE_RENDER_TARGET_OUTPUT;
swapChainDesc.BufferCount = 2; // use two buffers to enable flip effect
swapChainDesc.Scaling = DXGI_SCALING_NONE;
swapChainDesc.SwapEffect = DXGI_SWAP_EFFECT_FLIP_SEQUENTIAL; // we recommend using this swap effect for all applications
swapChainDesc.Flags = 0;
IDXGIDevice1* dxgiDevice;
Kore_Microsoft_affirm(device->QueryInterface(IID_IDXGIDevice1, (void**)&dxgiDevice));
IDXGIAdapter* dxgiAdapter;
Kore_Microsoft_affirm(dxgiDevice->GetAdapter(&dxgiAdapter));
IDXGIFactory2* dxgiFactory;
Kore_Microsoft_affirm(dxgiAdapter->GetParent(__uuidof(IDXGIFactory2), (void**)&dxgiFactory));
Kore_Microsoft_affirm(dxgiFactory->CreateSwapChainForCoreWindow(device, reinterpret_cast<IUnknown*>(CoreWindow::GetForCurrentThread()), &swapChainDesc,
nullptr, &swapChain));
Kore_Microsoft_affirm(dxgiDevice->SetMaximumFrameLatency(1));
#endif
#elif KORE_OCULUS
DXGI_SWAP_CHAIN_DESC scDesc = {0};
scDesc.BufferCount = 2;
scDesc.BufferDesc.Width = System::windowWidth(windowId);
scDesc.BufferDesc.Height = System::windowHeight(windowId);
scDesc.BufferDesc.Format = DXGI_FORMAT_R8G8B8A8_UNORM;
scDesc.BufferDesc.RefreshRate.Denominator = 1;
scDesc.BufferUsage = DXGI_USAGE_RENDER_TARGET_OUTPUT;
scDesc.OutputWindow = (HWND)System::windowHandle(windowId);
;
scDesc.SampleDesc.Count = antialiasingSamples() > 1 ? antialiasingSamples() : 1;
scDesc.SampleDesc.Quality = antialiasingSamples() > 1 ? D3D11_STANDARD_MULTISAMPLE_PATTERN : 0;
scDesc.Windowed = true;
scDesc.SwapEffect = DXGI_SWAP_EFFECT_SEQUENTIAL;
Windows::affirm(dxgiFactory->CreateSwapChain(device, &scDesc, &swapChain));
dxgiFactory->Release();
IDXGIDevice1* dxgiDevice = nullptr;
Windows::affirm(device->QueryInterface(__uuidof(IDXGIDevice1), (void**)&dxgiDevice));
Windows::affirm(dxgiDevice->SetMaximumFrameLatency(1));
dxgiDevice->Release();
#else
UINT flags = 0;
#ifdef _DEBUG
flags = D3D11_CREATE_DEVICE_DEBUG;
#endif
HRESULT result = D3D11CreateDeviceAndSwapChain(nullptr, D3D_DRIVER_TYPE_HARDWARE, nullptr, flags, featureLevels, 3, D3D11_SDK_VERSION, &swapChainDesc,
&swapChain, &device, nullptr, &context);
if (result != S_OK) {
Kore_Microsoft_affirm(D3D11CreateDeviceAndSwapChain(nullptr, D3D_DRIVER_TYPE_WARP, nullptr, flags, featureLevels, 3, D3D11_SDK_VERSION, &swapChainDesc,
&swapChain, &device, nullptr, &context));
}
#endif
}
#ifdef KORE_HOLOLENS
// holographicFrameController manages the targets and views for hololens.
// the views have to be created/deleted on the CameraAdded/Removed events
// at this point we don't know if this event has alread occured so we cannot
// simply set the renderTargetWidth, renderTargetHeight, currentRenderTargetViews and currentDepthStencilView.
// to bind the targets for hololens one has to use the VrInterface::beginRender(eye) instead of the methods in this class.
ComPtr<ID3D11Device> devicePtr = device;
ComPtr<ID3D11DeviceContext> contextPtr = context;
Microsoft::WRL::ComPtr<ID3D11Device4> device4Ptr;
Microsoft::WRL::ComPtr<ID3D11DeviceContext3> context3Ptr;
affirm(devicePtr.As(&device4Ptr));
affirm(contextPtr.As(&context3Ptr));
holographicFrameController->setDeviceAndContext(device4Ptr, context3Ptr);
#else
createBackbuffer(antialiasingSamples());
currentRenderTargetViews[0] = renderTargetView;
currentDepthStencilView = depthStencilView;
context->OMSetRenderTargets(1, &renderTargetView, depthStencilView);
CD3D11_VIEWPORT viewPort(0.0f, 0.0f, static_cast<float>(renderTargetWidth), static_cast<float>(renderTargetHeight));
context->RSSetViewports(1, &viewPort);
#endif
D3D11_SAMPLER_DESC samplerDesc;
ZeroMemory(&samplerDesc, sizeof(samplerDesc));
samplerDesc.AddressU = D3D11_TEXTURE_ADDRESS_WRAP;
samplerDesc.AddressV = D3D11_TEXTURE_ADDRESS_WRAP;
samplerDesc.AddressW = D3D11_TEXTURE_ADDRESS_WRAP;
samplerDesc.ComparisonFunc = D3D11_COMPARISON_NEVER;
samplerDesc.Filter = D3D11_FILTER_MIN_MAG_MIP_LINEAR;
samplerDesc.MaxLOD = D3D11_FLOAT32_MAX;
for (int i = 0; i < 16; ++i) {
lastSamplers[i] = samplerDesc;
}
initSamplers();
D3D11_BLEND_DESC blendDesc;
ZeroMemory(&blendDesc, sizeof(blendDesc));
D3D11_RENDER_TARGET_BLEND_DESC rtbd;
ZeroMemory(&rtbd, sizeof(rtbd));
rtbd.BlendEnable = true;
rtbd.SrcBlend = D3D11_BLEND_SRC_ALPHA;
rtbd.DestBlend = D3D11_BLEND_INV_SRC_ALPHA;
rtbd.BlendOp = D3D11_BLEND_OP_ADD;
rtbd.SrcBlendAlpha = D3D11_BLEND_ONE;
rtbd.DestBlendAlpha = D3D11_BLEND_ZERO;
rtbd.BlendOpAlpha = D3D11_BLEND_OP_ADD;
#ifdef KORE_WINDOWSAPP
rtbd.RenderTargetWriteMask = D3D11_COLOR_WRITE_ENABLE_ALL;
#else
rtbd.RenderTargetWriteMask = D3D10_COLOR_WRITE_ENABLE_ALL;
#endif
blendDesc.AlphaToCoverageEnable = false;
blendDesc.RenderTarget[0] = rtbd;
ID3D11BlendState* blending;
device->CreateBlendState(&blendDesc, &blending);
Kore_Microsoft_affirm(device->CreateBlendState(&blendDesc, &blending));
context->OMSetBlendState(blending, nullptr, 0xffffffff);
}
/* Initialize DirectX11 Graphics */
void nlInitD3D11( HWND hWnd, bool isFullScreen, nlEngineContext& cxt )
{
cxt.hwnd = hWnd;
IDXGIAdapter* pAdapter = NULL;
IDXGIDevice1* pDXGI = NULL;
IDXGIFactory* pDXGIFactory = NULL;
D3D_FEATURE_LEVEL fl;
/* FeatureLevelは10.1(SM4.0)で固定する */
const D3D_FEATURE_LEVEL featureLevel = D3D_FEATURE_LEVEL_10_0;
NL_HR_VALID( D3D11CreateDevice( NULL, D3D_DRIVER_TYPE_HARDWARE,(HMODULE)0,0,&featureLevel,1, D3D11_SDK_VERSION, &cxt.d3dDevice, &fl, &cxt.d3dContext ) );
NL_HR_ASSSERT( fl == D3D_FEATURE_LEVEL_10_0 );
/* create DXGI */
NL_HR_VALID( cxt.d3dDevice->QueryInterface(__uuidof(IDXGIDevice1), (void**)&pDXGI) );
/* get adapter info */
NL_HR_VALID( pDXGI->GetAdapter(&pAdapter) );
NL_HR_ASSSERT( pAdapter != NULL );
/* get factory */
NL_HR_VALID( pAdapter->GetParent( __uuidof(IDXGIFactory), (void**)&pDXGIFactory) );
NL_HR_ASSSERT( pDXGIFactory != NULL );
{/* create swap chain */
DXGI_SWAP_CHAIN_DESC swapChainDesc =
{
/* DXGI_MODE_DESC */
{cxt.rendertargets[0].width_, cxt.rendertargets[0].height_, {60,1}, DXGI_FORMAT_R8G8B8A8_UNORM, DXGI_MODE_SCANLINE_ORDER_UNSPECIFIED, DXGI_MODE_SCALING_UNSPECIFIED },
/* DXGI_SAMPLE_DESC */
{1, 0},
/* BufferUsage */
DXGI_USAGE_RENDER_TARGET_OUTPUT,
/* BufferCount */
3,
/* OutputWindow */
hWnd,
/* Windowed */
!isFullScreen,
/* DXGI_SWAP_EFFECT */
DXGI_SWAP_EFFECT_DISCARD,
/* Flags */
DXGI_SWAP_CHAIN_FLAG_ALLOW_MODE_SWITCH,
};
NL_HR_VALID( pDXGIFactory->CreateSwapChain(cxt.d3dDevice, &swapChainDesc, &cxt.dxgiSwpChain) );
}
/* Disalbe "Alt+Enter" and so on. must call this after CreateSwapChain() call MakeWindowAssociation(). */
NL_HR_VALID( pDXGIFactory->MakeWindowAssociation(hWnd, DXGI_MWA_NO_WINDOW_CHANGES | DXGI_MWA_NO_ALT_ENTER | DXGI_MWA_NO_PRINT_SCREEN ));
{/* get backbuffer view */
D3D11_TEXTURE2D_DESC desc;
cxt.rendertargets[0].renderTargetShaderResource_ = NULL;
NL_HR_VALID( cxt.dxgiSwpChain->GetBuffer( 0, __uuidof(ID3D11Texture2D), (void**)(&cxt.rendertargets[0].renderTarget_) ) );
NL_HR_VALID( cxt.d3dDevice->CreateRenderTargetView( cxt.rendertargets[0].renderTarget_, NULL, &cxt.rendertargets[0].renderTargetView_ ) );
cxt.rendertargets[0].renderTarget_->GetDesc( &desc );
cxt.rendertargets[0].width_ = desc.Width;
cxt.rendertargets[0].height_ = desc.Height;
}
{/* create and set depthStencil */
D3D11_TEXTURE2D_DESC depthDesc =
{
/*UINT Width;*/
cxt.rendertargets[0].width_,
/*UINT Height;*/
cxt.rendertargets[0].height_,
/*UINT MipLevels;*/
1,
/*UINT ArraySize;*/
1,
/*DXGI_FORMAT Format;*/
DXGI_FORMAT_D24_UNORM_S8_UINT,
/*DXGI_SAMPLE_DESC SampleDesc;*/
{1,0},
/*D3D11_USAGE Usage;*/
D3D11_USAGE_DEFAULT,
/*UINT BindFlags;*/
D3D11_BIND_DEPTH_STENCIL,
/*UINT CPUAccessFlags;*/
0,
/*UINT MiscFlags;*/
0,
};
D3D11_DEPTH_STENCIL_VIEW_DESC dsvDesc =
{
/* DXGI_FORMAT Format; */
DXGI_FORMAT_D24_UNORM_S8_UINT,
/* D3D11_DSV_DIMENSION ViewDimension; */
D3D11_DSV_DIMENSION_TEXTURE2DMS,
/* UINT Flags; */
0,
/* D3D11_TEX2D_DSV */
{0}
};
cxt.depthStencils[0].width = depthDesc.Width;
cxt.depthStencils[0].height = depthDesc.Height;
NL_HR_VALID( cxt.d3dDevice->CreateTexture2D(&depthDesc, NULL, &cxt.depthStencils[0].tex ) );
NL_HR_VALID( cxt.d3dDevice->CreateDepthStencilView(cxt.depthStencils[0].tex, &dsvDesc, &cxt.depthStencils[0].view) );
}
cxt.d3dContext->OMSetRenderTargets(1, &cxt.rendertargets[0].renderTargetView_, cxt.depthStencils[0].view );
/* デフォルトの設定 */
D3D11_VIEWPORT viewportDesc =
{
/* FLOAT TopLeftX; */
0.0f,
/* FLOAT TopLeftY; */
0.0f,
/* FLOAT Width; */
(FLOAT)cxt.rendertargets[0].width_,
/* FLOAT Height; */
(FLOAT)cxt.rendertargets[0].height_,
/* FLOAT MinDepth; */
0.0f,
/* FLOAT MaxDepth; */
1.0f,
};
cxt.viewportDesc = viewportDesc;
nlUpdateViewPortSetting(cxt);
/**/
D3D11_RASTERIZER_DESC rasterDesc =
{
/* D3D11_FILL_MODE FillMode; */
D3D11_FILL_SOLID,
/* D3D11_CULL_MODE CullMode; */
D3D11_CULL_NONE,
/* BOOL FrontCounterClockwise; */
0,
/* INT DepthBias; */
0,
/* FLOAT DepthBiasClamp; */
0,
/* FLOAT SlopeScaledDepthBias; */
0,
/* BOOL DepthClipEnable; */
TRUE,
/* BOOL ScissorEnable; */
0,
/* BOOL MultisampleEnable; */
0,
/* BOOL AntialiasedLineEnable; */
0
};
cxt.rasterDesc = rasterDesc;
nlUpdateRasterizeSetting(cxt);
/**/
D3D11_DEPTH_STENCIL_DESC depthStencilDesc =
{
/* BOOL DepthEnable; */
TRUE,
/* D3D11_DEPTH_WRITE_MASK DepthWriteMask; */
D3D11_DEPTH_WRITE_MASK_ALL,
/* D3D11_COMPARISON_FUNC DepthFunc; */
D3D11_COMPARISON_LESS,
/* BOOL StencilEnable; */
FALSE,
/* UINT8 StencilReadMask; */
0,
/* UINT8 StencilWriteMask; */
0,
/* D3D11_DEPTH_STENCILOP_DESC FrontFace; ダミーデータであることに注意*/
{ D3D11_STENCIL_OP_KEEP, D3D11_STENCIL_OP_KEEP, D3D11_STENCIL_OP_KEEP, D3D11_COMPARISON_NEVER },
/* D3D11_DEPTH_STENCILOP_DESC BackFace; */
{ D3D11_STENCIL_OP_KEEP, D3D11_STENCIL_OP_KEEP, D3D11_STENCIL_OP_KEEP, D3D11_COMPARISON_NEVER },
};
ID3D11DepthStencilState* depthStencilState;
cxt.d3dDevice->CreateDepthStencilState(&depthStencilDesc, &depthStencilState );
cxt.d3dContext->OMSetDepthStencilState(depthStencilState, 0);
depthStencilState->Release();
/**/
D3D11_SAMPLER_DESC samplerDesc =
{
/*D3D11_FILTER Filter;*/
D3D11_FILTER_MIN_MAG_MIP_LINEAR,
/* D3D11_TEXTURE_ADDRESS_MODE AddressU;*/
D3D11_TEXTURE_ADDRESS_WRAP,
/* D3D11_TEXTURE_ADDRESS_MODE AddressV;*/
D3D11_TEXTURE_ADDRESS_WRAP,
/* D3D11_TEXTURE_ADDRESS_MODE AddressW;*/
D3D11_TEXTURE_ADDRESS_WRAP,
/* FLOAT MipLODBias;*/
0.0f,
/* UINT MaxAnisotropy;*/
1,
/* D3D11_COMPARISON_FUNC ComparisonFunc;*/
D3D11_COMPARISON_ALWAYS,
/* FLOAT BorderColor[ 4 ];*/
{0.0f,0.0f,0.0f,0.0f},
/* FLOAT MinLOD;*/
0,
/* FLOAT MaxLOD;*/
D3D11_FLOAT32_MAX,
};
cxt.samplerDesc = samplerDesc;
/**/
nlUpdateSamplerState(cxt);
}
void Graphics::init(int windowId, int depthBufferBits, int stencilBufferBits) {
for (int i = 0; i < 1024 * 4; ++i) vertexConstants[i] = 0;
for (int i = 0; i < 1024 * 4; ++i) fragmentConstants[i] = 0;
HWND hwnd = (HWND)System::windowHandle(windowId);
UINT creationFlags = D3D11_CREATE_DEVICE_BGRA_SUPPORT;
#ifdef _DEBUG
creationFlags |= D3D11_CREATE_DEVICE_DEBUG;
#endif
D3D_FEATURE_LEVEL featureLevels[] = {
#ifdef SYS_WINDOWSAPP
D3D_FEATURE_LEVEL_11_1,
#endif
D3D_FEATURE_LEVEL_11_0, D3D_FEATURE_LEVEL_10_1, D3D_FEATURE_LEVEL_10_0, D3D_FEATURE_LEVEL_9_3, D3D_FEATURE_LEVEL_9_2, D3D_FEATURE_LEVEL_9_1};
// ID3D11Device* device0;
// ID3D11DeviceContext* context0;
#ifdef SYS_WINDOWSAPP
affirm(D3D11CreateDevice(nullptr, D3D_DRIVER_TYPE_HARDWARE, nullptr, creationFlags, featureLevels, ARRAYSIZE(featureLevels), D3D11_SDK_VERSION, &device,
&featureLevel, &context));
#endif
// affirm(device0.As(&device));
// affirm(context0.As(&context));
// m_windowBounds = m_window->Bounds;
if (swapChain != nullptr) {
affirm(swapChain->ResizeBuffers(2, 0, 0, DXGI_FORMAT_B8G8R8A8_UNORM, 0));
}
else {
#ifdef SYS_WINDOWS
DXGI_SWAP_CHAIN_DESC swapChainDesc = {0};
swapChainDesc.BufferUsage = DXGI_USAGE_RENDER_TARGET_OUTPUT;
swapChainDesc.BufferDesc.RefreshRate.Denominator = 1; // 60Hz
swapChainDesc.BufferDesc.RefreshRate.Numerator = 60;
swapChainDesc.BufferDesc.Width = System::windowWidth(windowId); // use automatic sizing
swapChainDesc.BufferDesc.Height = System::windowHeight(windowId);
swapChainDesc.BufferDesc.Format = DXGI_FORMAT_B8G8R8A8_UNORM; // this is the most common swapchain format
// swapChainDesc.Stereo = false;
swapChainDesc.SampleDesc.Count = 1; // don't use multi-sampling
swapChainDesc.SampleDesc.Quality = 0;
swapChainDesc.BufferUsage = DXGI_USAGE_RENDER_TARGET_OUTPUT;
swapChainDesc.BufferCount = 2; // use two buffers to enable flip effect
swapChainDesc.BufferDesc.ScanlineOrdering = DXGI_MODE_SCANLINE_ORDER_UNSPECIFIED;
swapChainDesc.BufferDesc.Scaling = DXGI_MODE_SCALING_UNSPECIFIED; // DXGI_SCALING_NONE;
swapChainDesc.SwapEffect = DXGI_SWAP_EFFECT_DISCARD; // DXGI_SWAP_EFFECT_FLIP_SEQUENTIAL; // we recommend using this swap effect for all applications
swapChainDesc.Flags = 0;
swapChainDesc.OutputWindow = (HWND)System::windowHandle(windowId);
swapChainDesc.Windowed = true;
#endif
#ifdef SYS_WINDOWSAPP
DXGI_SWAP_CHAIN_DESC1 swapChainDesc = {0};
swapChainDesc.Width = 0; // use automatic sizing
swapChainDesc.Height = 0;
swapChainDesc.Format = DXGI_FORMAT_B8G8R8A8_UNORM; // this is the most common swapchain format
swapChainDesc.Stereo = false;
swapChainDesc.SampleDesc.Count = 1; // don't use multi-sampling
swapChainDesc.SampleDesc.Quality = 0;
swapChainDesc.BufferUsage = DXGI_USAGE_RENDER_TARGET_OUTPUT;
swapChainDesc.BufferCount = 2; // use two buffers to enable flip effect
swapChainDesc.Scaling = DXGI_SCALING_NONE;
swapChainDesc.SwapEffect = DXGI_SWAP_EFFECT_FLIP_SEQUENTIAL; // we recommend using this swap effect for all applications
swapChainDesc.Flags = 0;
IDXGIDevice1* dxgiDevice;
affirm(device->QueryInterface(IID_IDXGIDevice1, (void**)&dxgiDevice));
IDXGIAdapter* dxgiAdapter;
affirm(dxgiDevice->GetAdapter(&dxgiAdapter));
IDXGIFactory2* dxgiFactory;
affirm(dxgiAdapter->GetParent(__uuidof(IDXGIFactory2), (void**)&dxgiFactory));
affirm(dxgiFactory->CreateSwapChainForCoreWindow(device, reinterpret_cast<IUnknown*>(CoreWindow::GetForCurrentThread()), &swapChainDesc, nullptr,
&swapChain));
affirm(dxgiDevice->SetMaximumFrameLatency(1));
#else
UINT flags = 0;
#ifdef _DEBUG
flags = D3D11_CREATE_DEVICE_DEBUG;
#endif
affirm(D3D11CreateDeviceAndSwapChain(nullptr, D3D_DRIVER_TYPE_HARDWARE, nullptr, flags, featureLevels, 6, D3D11_SDK_VERSION, &swapChainDesc, &swapChain,
&device, nullptr, &context));
#endif
}
ID3D11Texture2D* backBuffer;
affirm(swapChain->GetBuffer(0, __uuidof(ID3D11Texture2D), (void**)&backBuffer));
affirm(device->CreateRenderTargetView(backBuffer, nullptr, &renderTargetView));
D3D11_TEXTURE2D_DESC backBufferDesc;
backBuffer->GetDesc(&backBufferDesc);
renderTargetWidth = backBufferDesc.Width;
renderTargetHeight = backBufferDesc.Height;
// TODO (DK) map depth/stencilBufferBits arguments
CD3D11_TEXTURE2D_DESC depthStencilDesc(DXGI_FORMAT_D24_UNORM_S8_UINT, backBufferDesc.Width, backBufferDesc.Height, 1, 1, D3D11_BIND_DEPTH_STENCIL);
ID3D11Texture2D* depthStencil;
affirm(device->CreateTexture2D(&depthStencilDesc, nullptr, &depthStencil));
affirm(device->CreateDepthStencilView(depthStencil, &CD3D11_DEPTH_STENCIL_VIEW_DESC(D3D11_DSV_DIMENSION_TEXTURE2D), &depthStencilView));
context->OMSetRenderTargets(1, &renderTargetView, depthStencilView);
CD3D11_VIEWPORT viewPort(0.0f, 0.0f, static_cast<float>(backBufferDesc.Width), static_cast<float>(backBufferDesc.Height));
context->RSSetViewports(1, &viewPort);
D3D11_DEPTH_STENCIL_DESC desc;
ZeroMemory(&desc, sizeof(desc));
desc.DepthEnable = TRUE;
desc.DepthWriteMask = D3D11_DEPTH_WRITE_MASK_ALL;
desc.DepthFunc = D3D11_COMPARISON_LESS;
desc.StencilEnable = FALSE;
desc.StencilReadMask = D3D11_DEFAULT_STENCIL_READ_MASK;
desc.StencilWriteMask = D3D11_DEFAULT_STENCIL_WRITE_MASK;
desc.FrontFace.StencilFunc = desc.BackFace.StencilFunc = D3D11_COMPARISON_ALWAYS;
desc.FrontFace.StencilDepthFailOp = desc.BackFace.StencilDepthFailOp = D3D11_STENCIL_OP_KEEP;
desc.FrontFace.StencilPassOp = desc.BackFace.StencilPassOp = D3D11_STENCIL_OP_KEEP;
desc.FrontFace.StencilFailOp = desc.BackFace.StencilFailOp = D3D11_STENCIL_OP_KEEP;
context->OMSetDepthStencilState(getDepthStencilState(desc), lastStencilReferenceValue);
lastDepthStencil = desc;
D3D11_RASTERIZER_DESC rasterDesc;
rasterDesc.FillMode = D3D11_FILL_SOLID;
rasterDesc.CullMode = D3D11_CULL_NONE;
rasterDesc.FrontCounterClockwise = FALSE;
rasterDesc.DepthBias = 0;
rasterDesc.SlopeScaledDepthBias = 0.0f;
rasterDesc.DepthBiasClamp = 0.0f;
rasterDesc.DepthClipEnable = TRUE;
rasterDesc.ScissorEnable = FALSE;
rasterDesc.MultisampleEnable = FALSE;
rasterDesc.AntialiasedLineEnable = FALSE;
ID3D11RasterizerState* rasterState;
device->CreateRasterizerState(&rasterDesc, &rasterState);
context->RSSetState(rasterState);
D3D11_BLEND_DESC blendDesc;
ZeroMemory(&blendDesc, sizeof(blendDesc));
D3D11_RENDER_TARGET_BLEND_DESC rtbd;
ZeroMemory(&rtbd, sizeof(rtbd));
rtbd.BlendEnable = true;
rtbd.SrcBlend = D3D11_BLEND_SRC_ALPHA;
rtbd.DestBlend = D3D11_BLEND_INV_SRC_ALPHA;
rtbd.BlendOp = D3D11_BLEND_OP_ADD;
rtbd.SrcBlendAlpha = D3D11_BLEND_ONE;
rtbd.DestBlendAlpha = D3D11_BLEND_ZERO;
rtbd.BlendOpAlpha = D3D11_BLEND_OP_ADD;
#ifdef SYS_WINDOWSAPP
rtbd.RenderTargetWriteMask = D3D11_COLOR_WRITE_ENABLE_ALL;
#else
rtbd.RenderTargetWriteMask = D3D10_COLOR_WRITE_ENABLE_ALL;
#endif
blendDesc.AlphaToCoverageEnable = false;
blendDesc.RenderTarget[0] = rtbd;
ID3D11BlendState* blending;
device->CreateBlendState(&blendDesc, &blending);
affirm(device->CreateBlendState(&blendDesc, &blending));
context->OMSetBlendState(blending, nullptr, 0xffffffff);
#ifdef SYS_WINDOWS
if (System::hasShowWindowFlag()) {
ShowWindow(hwnd, SW_SHOWDEFAULT);
UpdateWindow(hwnd);
}
#endif
System::makeCurrent(windowId);
}
HRESULT D3D11Renderer::Create( HWND const &appWindow )
{
HRESULT hr;
D3D_FEATURE_LEVEL featureLevelsSupported;
D3D_FEATURE_LEVEL featureLevelsRequested[] =
{
D3D_FEATURE_LEVEL_11_0,
D3D_FEATURE_LEVEL_10_1,
D3D_FEATURE_LEVEL_10_0,
D3D_FEATURE_LEVEL_9_3,
D3D_FEATURE_LEVEL_9_2,
D3D_FEATURE_LEVEL_9_1,
};
UINT deviceFlags = 0;
#if defined(DEBUG) || defined(_DEBUG)
deviceFlags |= (D3D11_CREATE_DEVICE_DEBUG | D3D11_RLDO_DETAIL);
#endif
HR(hr, D3D11CreateDevice(
GetPrimaryAdaptor(), // adapter
D3D_DRIVER_TYPE_HARDWARE, // drive type
0, // hmodule
deviceFlags, // device flags
featureLevelsRequested, // array of feature levels requests
6, // number of feature levels
D3D11_SDK_VERSION, // sdk version
&m_device, // pointer to device
&featureLevelsSupported, // number of feature levels supported
&m_context)); // pointer to context
/*
#if defined(DEBUG) || defined(_DEBUG)
HR(hr, m_device->QueryInterface(__uuidof(ID3D11Debug), (void **)&m_debug));
#endif
*/
DXGI_FORMAT formats[] =
{
g_settings.format,
DXGI_FORMAT_R16G16B16A16_FLOAT,
DXGI_FORMAT_R8G8B8A8_UNORM
};
UINT formatSupport = 0;
UINT supportedFormatIndex = 0;
for (supportedFormatIndex; supportedFormatIndex < 3; supportedFormatIndex++)
{
m_device->CheckFormatSupport(formats[supportedFormatIndex], &formatSupport);
if (formatSupport & D3D11_FORMAT_SUPPORT_RENDER_TARGET && formatSupport & D3D11_FORMAT_SUPPORT_DISPLAY)
{
g_settings.format = formats[supportedFormatIndex];
break;
}
}
ATOM_ASSERT(g_settings.xmsaa > 0, "XMSAA < 0, min value = 1");
UINT sampleCount = g_settings.xmsaa;
UINT numQualityLevels = 0;
this->m_device->CheckMultisampleQualityLevels(
g_settings.format,
sampleCount,
&numQualityLevels);
//this->m_appSettings->qmsaa = numQualityLevels - 1;
if (sampleCount < g_settings.xmsaa)
g_settings.xmsaa = sampleCount;
if (numQualityLevels - 1 < g_settings.qmsaa)
g_settings.qmsaa = numQualityLevels - 1;
DXGI_SWAP_CHAIN_DESC sd;
ZeroMemory(&sd, sizeof(sd));
sd.BufferCount = SWAP_CHAIN_BUFFER_COUNT;
sd.BufferDesc.Format = g_settings.format;
sd.BufferDesc.Width = g_settings.width;
sd.BufferDesc.Height = g_settings.height;
sd.BufferUsage = DXGI_USAGE_RENDER_TARGET_OUTPUT;
sd.SwapEffect = DXGI_SWAP_EFFECT_DISCARD;
sd.OutputWindow = appWindow;
sd.SampleDesc.Count = g_settings.xmsaa;
sd.SampleDesc.Quality = g_settings.qmsaa;
sd.Windowed = true;
GetDefaultRefreshRate();
if (g_settings.frameRate <= 0)
{
DXGI_RATIONAL fr = GetDefaultRefreshRate();
sd.BufferDesc.RefreshRate.Numerator = fr.Numerator;
sd.BufferDesc.RefreshRate.Denominator = fr.Denominator;
g_settings.frameRate = fr.Numerator / fr.Denominator;
}
else
{
sd.BufferDesc.RefreshRate.Numerator = g_settings.frameRate;
sd.BufferDesc.RefreshRate.Denominator = 1;
}
IDXGIDevice1 *dxgiDevice = 0;
IDXGIAdapter1 *dxgiAdapter = 0;
IDXGIFactory1 *dxgiFactory = 0;
HR(hr, m_device->QueryInterface(__uuidof(IDXGIDevice1), (void **)&dxgiDevice));
HR(hr, dxgiDevice->GetParent(__uuidof(IDXGIAdapter1), (void **)&dxgiAdapter));
HR(hr, dxgiAdapter->GetParent(__uuidof(IDXGIFactory1), (void **)&dxgiFactory));
HR(hr, dxgiFactory->CreateSwapChain((IUnknown *)m_device, &sd, &m_swapChain));
memory::SafeRelease(&dxgiDevice);
memory::SafeRelease(&dxgiAdapter);
memory::SafeRelease(&dxgiFactory);
//LOG("num: %d, den: %d\n", sd.BufferDesc.RefreshRate.Numerator, sd.BufferDesc.RefreshRate.Denominator);
//LOG("scaling: %d, scanline ordering: %d\n", sd.BufferDesc.Scaling, sd.BufferDesc.ScanlineOrdering);
#if defined(DEBUG) || defined(_DEBUG)
//EnumerateDisplayModes();
char *featureLevelNames[] = { "D3D11", "D3D10.1", "D3D10", "D3D9.3", "D3D9.2", "D3D9.1" };
for (int i = 0; i < 6; i++)
{
if (featureLevelsSupported == featureLevelsRequested[i])
ATOM_LOG("[info]: D3D_FEATURE_LEVEL: %s\n", featureLevelNames[i]);
}
ATOM_LOG("[info]: using format: %d, index: %d\n", formats[supportedFormatIndex], supportedFormatIndex);
#endif
InitRendererResources();
return Resize(g_settings.width, g_settings.height);
}
