Flickering using DirectXTK SpriteBatch - c++

Question

I am using the DirectXTK SpriteBatch class for rendering sprites. The problem is that the sprite flickers. I suppose it's due to the front/back buffer switching.
Is it possible to avoid this flicker effect?
My render code looks like:
void Render(float elapsedTime)
{
ID2D1DeviceContext* d2dContext = g_devResources->GetD2dDeviceContext();
// Draw sprite
g_SpriteBatch->Begin(SpriteSortMode_Deferred);
{
g_SpriteBatch->Draw(g_texture, XMFLOAT2(10, 75), nullptr, Colors::White);
}
g_SpriteBatch->End();
}
And the windows size dependent initialization code as follows:
void DeviceResources::InitWindowSizeDependentResources(HWND hWnd)
{
HRESULT hr;
// Identify the physical adapter (GPU or card) this device is runs on.
ComPtr<IDXGIAdapter> dxgiAdapter;
hr = m_dxgiDevice->GetAdapter(&dxgiAdapter);
if (FAILED(hr))
{
throw std::exception("Identification of IDXGIAdapter failed");
}
// Get the factory object that created the DXGI device.
ComPtr<IDXGIFactory2> dxgiFactory;
hr = dxgiAdapter->GetParent(IID_PPV_ARGS(&dxgiFactory));
if (FAILED(hr))
{
throw std::exception("Get IDXGIFactory2 failed");
}
// Allocate a swap chain descriptor.
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 double buffering to enable flip
swapChainDesc.Scaling = DXGI_SCALING_NONE;
swapChainDesc.SwapEffect = DXGI_SWAP_EFFECT_FLIP_SEQUENTIAL; // all apps must use this SwapEffect
swapChainDesc.Flags = 0;
// Get the final swap chain for this window from the DXGI factory.
hr = dxgiFactory->CreateSwapChainForHwnd(
m_d3dDevice.Get(),
hWnd,
&swapChainDesc,
NULL,
NULL,
&m_dxgiSwapChain
);
if (FAILED(hr))
{
throw std::exception("Creation of IDXGISwapChain failed");
}
// Ensure that DXGI doesn't queue more than one frame at a time (minimize power consumption).
hr = m_dxgiDevice->SetMaximumFrameLatency(1);
if (FAILED(hr))
{
throw std::exception("Set MaximumFrameLatency failed");
}
// Get the backbuffer for this window which is be the final 3D render target.
ComPtr<ID3D11Texture2D> backBuffer;
hr = m_dxgiSwapChain->GetBuffer(0, IID_PPV_ARGS(&backBuffer));
if (FAILED(hr))
{
throw std::exception("Get BackBuffer failed");
}
hr = m_d3dDevice->CreateRenderTargetView(backBuffer.Get(), nullptr, &m_d3dRenderTargetView);
// Now we set up the Direct2D render target bitmap linked to the swapchain.
// Whenever we render to this bitmap, it is directly rendered to the
// swap chain associated with the window.
D2D1_BITMAP_PROPERTIES1 bitmapProperties =
D2D1::BitmapProperties1(
D2D1_BITMAP_OPTIONS_TARGET | D2D1_BITMAP_OPTIONS_CANNOT_DRAW,
D2D1::PixelFormat(DXGI_FORMAT_B8G8R8A8_UNORM, D2D1_ALPHA_MODE_IGNORE),
96.0f, // dpi x
96.0f // dpi y
);
// Direct2D needs the dxgi version of the backbuffer surface pointer.
ComPtr<IDXGISurface> dxgiBackBuffer;
hr = m_dxgiSwapChain->GetBuffer(0, IID_PPV_ARGS(&dxgiBackBuffer));
if (FAILED(hr))
{
throw std::exception("Get BackBuffer failed");
}
// Get a D2D surface from the DXGI back buffer to use as the D2D render target.
hr = m_d2dContext->CreateBitmapFromDxgiSurface(
dxgiBackBuffer.Get(),
bitmapProperties,
m_d2dRenderTargetBitmap.GetAddressOf());
if (FAILED(hr))
{
throw std::exception("CreateBitmapFromDxgiSurface failed");
}
// Now we can set the Direct2D render target.
m_d2dContext->SetTarget(m_d2dRenderTargetBitmap.Get());
// tell DirectX how to scale its logical coordinate system to physical display
float dpiX, dpiY;
m_d2dFactory1->GetDesktopDpi(&dpiX, &dpiY);
m_d2dContext->SetDpi(dpiX, dpiY);
// Create depth stencil texture
D3D11_TEXTURE2D_DESC descDepth;
ZeroMemory(&descDepth, sizeof(descDepth));
descDepth.Width = 640;
descDepth.Height = 480;
descDepth.MipLevels = 1;
descDepth.ArraySize = 1;
descDepth.Format = DXGI_FORMAT_D24_UNORM_S8_UINT;
descDepth.SampleDesc.Count = 1;
descDepth.SampleDesc.Quality = 0;
descDepth.Usage = D3D11_USAGE_DEFAULT;
descDepth.BindFlags = D3D11_BIND_DEPTH_STENCIL;
descDepth.CPUAccessFlags = 0;
descDepth.MiscFlags = 0;
hr = m_d3dDevice->CreateTexture2D(&descDepth, nullptr, &m_d3dDepthStencil);
if (FAILED(hr))
{
throw std::exception("CreateTexture2D failed");
}
// Create the depth stencil view
D3D11_DEPTH_STENCIL_VIEW_DESC descDSV;
ZeroMemory(&descDSV, sizeof(descDSV));
descDSV.Format = descDepth.Format;
descDSV.ViewDimension = D3D11_DSV_DIMENSION_TEXTURE2D;
descDSV.Texture2D.MipSlice = 0;
hr = m_d3dDevice->CreateDepthStencilView(m_d3dDepthStencil.Get(), &descDSV, &m_d3dDepthStencilView);
if (FAILED(hr))
{
throw std::exception("CreateDepthStencilView failed");
}
m_d3dContext->OMSetRenderTargets(1, m_d3dRenderTargetView.GetAddressOf(), m_d3dDepthStencilView.Get());
// Setup the viewport
// todo: wozu genau? (eingebaut, damit es in SpriteBatch.End() nicht knallt...)
D3D11_VIEWPORT vp;
vp.Width = 640.0f;
vp.Height = 480.0f;
vp.MinDepth = 0.0f;
vp.MaxDepth = 1.0f;
vp.TopLeftX = 0;
vp.TopLeftY = 0;
m_d3dContext->RSSetViewports(1, &vp);
}
Thanks in advance!