Direct3D Renders to wrong texture

Question

In the code below I try render a sphere to a texture (renderTargetView), that texture is supposed to be rendered to the back buffer on a quad. I'm experimenting with it to use with glow later. The problem right now is that the sphere is rendered to the back buffer and is visible, it doesn't even matter if I comment out the lower half of the code, same result. I'm using this background color D3DXCOLOR(0.4f, 0.2f, 0.0f) here, but that is not what's on the screen, it's the color set with back buffer devcon->ClearRenderTargetView(backbuffer, D3DXCOLOR(0.0f, 0.2f, 0.4f, 1.0f)); that is showing.

        // Set and clear render target
        devcon->OMSetRenderTargets(1, &renderTargetView, zbuffer);
        devcon->ClearRenderTargetView(renderTargetView, D3DXCOLOR(0.4f, 0.2f, 0.0f, 1.0f));

        devcon->PSSetShaderResources(0, 1, &pTextureSun);
        devcon->UpdateSubresource(pCBuffer, 0, 0, &cBuffer, 0, 0);
        devcon->Draw(sizeOfVertexVector, 0);

        // set the shader objects
        /*
        devcon->VSSetShader(pVS_glow, 0, 0);
        devcon->PSSetShader(pPS_glow, 0, 0);

        // set the render target as the back buffer
        devcon->OMSetRenderTargets(1, &backbuffer, zbuffer);

        devcon->IASetVertexBuffers(0, 1, &pVBufferQuad, &stride, &offset);
        devcon->UpdateSubresource(pCBuffer, 0, 0, &cBuffer, 0, 0);
        devcon->PSSetShaderResources(0, 1, &shaderResourceView);
        devcon->Draw(6, 0);*/

Here is where the back and depth buffers set up (I have been trying with different formats such as DXGI_FORMAT_D24_UNORM_S8_UINT for depth buffer and others but no luck):

// create a struct to hold information about the swap chain
DXGI_SWAP_CHAIN_DESC scd;

// clear out the struct for use
ZeroMemory(&scd, sizeof(DXGI_SWAP_CHAIN_DESC));

// fill the swap chain description struct
scd.BufferCount = 1;                                   // one back buffer
scd.BufferDesc.Format = DXGI_FORMAT_R8G8B8A8_UNORM;    // use 32-bit color
scd.BufferDesc.Width = SCREEN_WIDTH;                   // set the back buffer width
scd.BufferDesc.Height = SCREEN_HEIGHT;                 // set the back buffer height
scd.BufferUsage = DXGI_USAGE_RENDER_TARGET_OUTPUT;     // how swap chain is to be used
scd.OutputWindow = hWnd;                               // the window to be used
scd.SampleDesc.Count = 4;                              // how many multisamples
scd.Windowed = TRUE;                                   // windowed/full-screen mode
scd.Flags = DXGI_SWAP_CHAIN_FLAG_ALLOW_MODE_SWITCH;    // allow full-screen switching

// create a device, device context and swap chain using the information in the scd struct
D3D11CreateDeviceAndSwapChain(NULL,
    D3D_DRIVER_TYPE_HARDWARE,
    NULL,
    NULL,
    NULL,
    NULL,
    D3D11_SDK_VERSION,
    &scd,
    &swapchain,
    &dev,
    NULL,
    &devcon);


// create the depth buffer texture
D3D11_TEXTURE2D_DESC texd;
ZeroMemory(&texd, sizeof(texd));

texd.Width = SCREEN_WIDTH;
texd.Height = SCREEN_HEIGHT;
texd.ArraySize = 1;
texd.MipLevels = 1;
texd.SampleDesc.Count = 4;
texd.Format = DXGI_FORMAT_D24_UNORM_S8_UINT;
texd.BindFlags = D3D11_BIND_DEPTH_STENCIL;

ID3D11Texture2D *pDepthBuffer;
dev->CreateTexture2D(&texd, NULL, &pDepthBuffer);

// create the depth buffer
D3D11_DEPTH_STENCIL_VIEW_DESC dsvd;
ZeroMemory(&dsvd, sizeof(dsvd));

dsvd.Format = DXGI_FORMAT_D24_UNORM_S8_UINT;
dsvd.ViewDimension = D3D11_DSV_DIMENSION_TEXTURE2DMS;

dev->CreateDepthStencilView(pDepthBuffer, &dsvd, &zbuffer);
pDepthBuffer->Release();

// get the address of the back buffer
ID3D11Texture2D *pBackBuffer;
swapchain->GetBuffer(0, __uuidof(ID3D11Texture2D), (LPVOID*)&pBackBuffer);

// use the back buffer address to create the render target
dev->CreateRenderTargetView(pBackBuffer, NULL, &backbuffer);
pBackBuffer->Release();

// set the render target as the back buffer
devcon->OMSetRenderTargets(1, &backbuffer, zbuffer);


// Set the viewport
D3D11_VIEWPORT viewport;
ZeroMemory(&viewport, sizeof(D3D11_VIEWPORT));

viewport.TopLeftX = 0;    // set the left to 0
viewport.TopLeftY = 0;    // set the top to 0
viewport.Width = SCREEN_WIDTH;    // set the width to the window's width
viewport.Height = SCREEN_HEIGHT;    // set the height to the window's height
viewport.MinDepth = 0;    // the closest an object can be on the depth buffer is 0.0
viewport.MaxDepth = 1;    // the farthest an object can be on the depth buffer is 1.0

devcon->RSSetViewports(1, &viewport);

And the render-to-texture:

D3D11_TEXTURE2D_DESC textureDesc;
D3D11_RENDER_TARGET_VIEW_DESC renderTargetViewDesc;
D3D11_SHADER_RESOURCE_VIEW_DESC shaderResourceViewDesc;

// Initialize the render target texture description.
ZeroMemory(&textureDesc, sizeof(textureDesc));

// Setup the render target texture description.
textureDesc.Width = SCREEN_WIDTH;
textureDesc.Height = SCREEN_HEIGHT;
textureDesc.MipLevels = 1;
textureDesc.ArraySize = 1;
textureDesc.Format = DXGI_FORMAT_R32G32B32A32_FLOAT;
textureDesc.SampleDesc.Count = 1;
textureDesc.Usage = D3D11_USAGE_DEFAULT;
textureDesc.BindFlags = D3D11_BIND_RENDER_TARGET | D3D11_BIND_SHADER_RESOURCE;
textureDesc.CPUAccessFlags = 0;
textureDesc.MiscFlags = 0;

dev->CreateTexture2D(&textureDesc, NULL, &renderTargetTexture);

// Setup the description of the render target view.
renderTargetViewDesc.Format = textureDesc.Format;
renderTargetViewDesc.ViewDimension = D3D11_RTV_DIMENSION_TEXTURE2D;
renderTargetViewDesc.Texture2D.MipSlice = 0;

dev->CreateRenderTargetView(renderTargetTexture, &renderTargetViewDesc, &renderTargetView);

// Setup the description of the shader resource view.
shaderResourceViewDesc.Format = textureDesc.Format;
shaderResourceViewDesc.ViewDimension = D3D11_SRV_DIMENSION_TEXTURE2D;
shaderResourceViewDesc.Texture2D.MostDetailedMip = 0;
shaderResourceViewDesc.Texture2D.MipLevels = 1;

// Create the shader resource view.
dev->CreateShaderResourceView(renderTargetTexture, &shaderResourceViewDesc, &shaderResourceView);

Any ideas?

UPDATE

This code is executed before rendering to texture, if I comment out it..

        // set the render target as the back buffer
        devcon->OMSetRenderTargets(1, &backbuffer, zbuffer);
        cBuffer.doBlur = 0;
        devcon->PSSetShaderResources(0, 1, &pTextureEarth);
        devcon->UpdateSubresource(pCBuffer, 0, 0, &cBuffer, 0, 0);
        devcon->Draw(sizeOfVertexVector, 0);

...this now renders to texture, currently it just shows the background color of the texture, not the sphere.

        // Set and clear render target
        devcon->OMSetRenderTargets(1, &renderTargetView, zbuffer);
        devcon->ClearRenderTargetView(renderTargetView, D3DXCOLOR(0.4f, 0.2f, 0.0f, 0.3f));

        devcon->PSSetShaderResources(0, 1, &pTextureSun);
        devcon->UpdateSubresource(pCBuffer, 0, 0, &cBuffer, 0, 0);
        devcon->Draw(sizeOfVertexVector, 0);

        // set the shader objects
        devcon->IASetInputLayout(pLayoutGlow);
        devcon->VSSetShader(pVS_glow, 0, 0);
        devcon->PSSetShader(pPS_glow, 0, 0);

        // set the render target as the back buffer
        devcon->OMSetRenderTargets(1, &backbuffer, zbuffer);

        devcon->IASetVertexBuffers(0, 1, &pVBufferQuad, &stride, &offset);
        devcon->UpdateSubresource(pCBuffer, 0, 0, &cBuffer, 0, 0);
        devcon->PSSetShaderResources(0, 1, &shaderResourceView);
        devcon->Draw(6, 0);

Answer 1

The problem was that blend wasn't enabled.

Answer 2

I had problems with rendet to texture before because I bound a shader resource view to the same texture as what was the render target, which is forbidden. If you use Visual Studio 2012, you should try checking your code in debug mode. Aren't you making the same mistake as me?