2
\$\begingroup\$

I'm having some trouble using ID3D11DeviceContext::Map() correctly.

Here's the whole function so far:

 Color Graphics::GetPixel(int x, int y) const
{
    //Temp frame buffer descriptor;
    CD3D11_TEXTURE2D_DESC pFrameDesc;
    pFrameDesc.Width = WindowWidth;
    pFrameDesc.Height = WindowHeight;
    pFrameDesc.CPUAccessFlags = D3D11_CPU_ACCESS_READ;
    pFrameDesc.Format = DXGI_FORMAT_B8G8R8A8_UNORM;
    pFrameDesc.MipLevels = 1u;
    pFrameDesc.ArraySize = 1u;
    pFrameDesc.SampleDesc.Count = 1u;
    pFrameDesc.SampleDesc.Quality = 0u;
    pFrameDesc.Usage = D3D11_USAGE_DEFAULT;
    pFrameDesc.BindFlags = D3D11_BIND_UNORDERED_ACCESS;
    pFrameDesc.MiscFlags = 0u;

    // Create temp frame buffer(2d texture)
    wrl::ComPtr<ID3D11Texture2D>pFrame = nullptr;
    HRESULT hr = pDevice->CreateTexture2D(&pFrameDesc, nullptr, &pFrame);
    GFX_THROW_INFO(hr);

    hr = pSwapChain->GetBuffer(0, __uuidof(pFrame), &pFrame);
    GFX_THROW_INFO(hr);
    
    
    D3D11_MAPPED_SUBRESOURCE map;
    map.RowPitch = WindowWidth * 4;
    map.DepthPitch = WindowHeight * 4;
    
    //Throwing here, CPU access flags problem. 
    hr = pContext->Map(pFrame.Get(), 0u, D3D11_MAP_READ, 0u, &map);
    GFX_THROW_INFO(hr);

    pContext->Unmap(pFrame.Get(), 0u);
    


    return { 0.0f, 0.4f, 0.0f, 0.0f };
}

I'm getting an exception thrown at pContext->Map()

"Map cannot be called with MAP_READ access, because the Resource was not created with the D3D11_CPU_ACCESS_READ flag. "

Which is confusing as the newly created resource has the D3D11_CPU_ACCESS_READ flag enabled. This is also true If I try MAP_WRITE and change the access flags to match. I've also tried ORing the flags together with no luck.

The ultimate use of this function is to be able to create a CPU side array of Color objects (Colors are currently a struct of four floats) Which I can then send onto the NewTek NDI sdk. But I feel it would also be useful for saving screen shots, creating colour pickers etc.

Any ideas welcome!

\$\endgroup\$
0

2 Answers 2

Reset to default
5
\$\begingroup\$

Your code doesn't use your created texture with D3D11_CPU_ACCESS_READ.

It creates a texture:

// Create temp frame buffer(2d texture)
wrl::ComPtr<ID3D11Texture2D>pFrame = nullptr;
HRESULT hr = pDevice->CreateTexture2D(&pFrameDesc, nullptr, &pFrame);
GFX_THROW_INFO(hr);

Then it releases that texture and takes a reference to one from the swapchain (which is never set for CPU READ):

hr = pSwapChain->GetBuffer(0, __uuidof(pFrame), &pFrame);
GFX_THROW_INFO(hr);

Then you try to map the swapchain buffer:

hr = pContext->Map(pFrame.Get(), 0u, D3D11_MAP_READ, 0u, &map);
GFX_THROW_INFO(hr);
\$\endgroup\$
1
  • 2
    \$\begingroup\$ Always upvote @ChuckWalbourn on matters of DirectX :) \$\endgroup\$ Commented Nov 14, 2020 at 2:30
1
\$\begingroup\$

Chuck Walbourn's answer is correct, but to give you a bit more context, the texture you're creating with pDevice->CreateTexture2D is not the same as what you're getting with pSwapChain->GetBuffer.

With pDevice->CreateTexture2D, you are creating a brand new on-memory texture (which is indeed set to be read from the CPU). The new texture is stored in pFrame.

Then, with pSwapChain->GetBuffer, you are getting the existing back buffer from the swap chain (which was not created with CPU read access). This is stored in pFrame, effectively discarding the previous value.

You have two choices here (I haven't touched D3D11 in years. This is based on my D3D12, Vulkan and current-gen console knowledge)

Option A is to ditch the new on-memory texture, and instead set the back buffer in the swap chain for CPU access. I don't recommend you do this, since textures meant for CPU readback won't necessarily perform as well as those which are created without CPU access.

Also, while you have mapped memory, the GPU will have to flush the contents of the texture, and cease all GPU operations on it until you unmap the memory. Depending on where in your drawing process you're doing this, this operation will be a huge bottleneck.

By the way, I'm not even sure if Direct3D will allow you to create a swap chain with CPU read access, so you probably won't even be able to try it out.

Option B is to make a draw operation with a full screen textured quad, where the texture is the back buffer, and the render target is your CPU-readable texture. This is generally the preferred method, as it resolves all the problems Option A had, at the expense of one full screen draw operation.

Keep in mind that it is possible (I don't remember with D3D11) that you won't be able to set the back buffer as a texture for drawing. In that case, instead of making your game's draw calls directly to the back buffer, you might have to create yet another render target, draw everything to it, and then make two copies: one to the swap chain back buffer, and another one to your CPU-readable texture.

This method is a bit more complex, but is guaranteed to work on D3D12, as well as most likely every other modern platform.

\$\endgroup\$
1
  • \$\begingroup\$ TLDR version: Thanks!! Thanks for this detailed breakdown.Armed with this and with the help of some other directX11 peoples on a friendly discord server I managed to get the behaviour I was after. I ended up creating another GPU staging texture with CPU_Read flags enabled. Then used D3D11Subresource_Map to get a pointer to the second texture (which is now available to the CPU) Seems to be working well and I'm not noticing a performance hit although I haven't got a very complex scene by any means. Just wanted to say thanks! \$\endgroup\$ Commented Nov 15, 2020 at 19:41

Start asking to get answers

Find the answer to your question by asking.

Ask question

Explore related questions

See similar questions with these tags.