c++ - Directx11 - DeviceContext::ClearRenderTargetView 崩溃

Question

发生的事情是 ClearRenderTarget 在我的代码上不断崩溃，我想知道为什么。

这是我初始化 directX 及其所有代码的代码:

#include "d3d.h"

D3DClass::D3DClass(): m_depthStencilState(0), m_depthStencilView(0), m_device(0), m_deviceContext(0),
                      m_swapChain(0), m_rasterState(0), m_renderTargetView(0), m_depthStencilBuffer(0)
{  }

D3DClass::D3DClass(const D3DClass& other)
{ }

D3DClass::~D3DClass()
{ }

bool D3DClass::initialize(int screenWidth, int screenHeight, bool vsync, HWND hwnd, bool fullscreen, float screenDepth, float screenNear)
{
    HRESULT result;
    IDXGIFactory* factory;
    IDXGIAdapter* adapter;
    IDXGIOutput* adapterOutput;
    unsigned int numModes, numerator, denominator, stringLength;
    DXGI_MODE_DESC* displayModeList;
    DXGI_ADAPTER_DESC adapterDesc;
    int error;
    DXGI_SWAP_CHAIN_DESC swapChainDesc;
    D3D_FEATURE_LEVEL featureLevel;
    ID3D11Texture2D* backBufferPtr;
    D3D11_TEXTURE2D_DESC depthBufferDesc;   
    D3D11_DEPTH_STENCIL_DESC depthStencilDesc;
    D3D11_DEPTH_STENCIL_VIEW_DESC depthStencilViewDesc;
    D3D11_RASTERIZER_DESC rasterDesc;
    D3D11_VIEWPORT viewport;
    float fieldOfView, screenAspect;

    m_vsync_enabled = vsync;

    result = CreateDXGIFactory(__uuidof(IDXGIFactory), (void**)&factory);
    if (FAILED(result)) return false;

    if (FAILED(factory->EnumAdapters(0, &adapter))) return false;

    if (FAILED(adapter->EnumOutputs(0, &adapterOutput))) return false;

    if (FAILED(adapterOutput->GetDisplayModeList(DXGI_FORMAT_R8G8B8A8_UNORM, DXGI_ENUM_MODES_INTERLACED, &numModes, 0))) return false;

    displayModeList = new DXGI_MODE_DESC[numModes];
    if (!displayModeList) return false;

    if (FAILED(adapterOutput->GetDisplayModeList(DXGI_FORMAT_R8G8B8A8_UNORM, DXGI_ENUM_MODES_INTERLACED, &numModes, displayModeList))) return false;

    for (int i = 0; i < numModes; ++i)
    {
        if (displayModeList[i].Height == static_cast<unsigned int>(screenHeight))
        {
            numerator = displayModeList[i].RefreshRate.Numerator;
            denominator = displayModeList[i].RefreshRate.Denominator;
        }
    }

    if (FAILED(adapter->GetDesc(&adapterDesc))) return false;

    m_videoCardMemory = static_cast<int>(adapterDesc.DedicatedVideoMemory) / 1024 / 1024;

    error = wcstombs_s(&stringLength, m_videoCardDescription, 128, adapterDesc.Description, 128);
    if (error != 0) return false;

    delete[] displayModeList;
    displayModeList = 0;

    adapterOutput->Release();
    adapterOutput = 0;

    adapter->Release();
    adapter = 0;

    factory->Release();
    factory = 0;

    memset(&swapChainDesc, 0, sizeof(swapChainDesc));

    swapChainDesc.BufferCount = 1;

    swapChainDesc.BufferDesc.Width = screenWidth;
    swapChainDesc.BufferDesc.Height = screenHeight;

    swapChainDesc.BufferDesc.Format = DXGI_FORMAT_R8G8B8A8_UNORM;

    if(m_vsync_enabled)
    {
        swapChainDesc.BufferDesc.RefreshRate.Numerator = numerator;
        swapChainDesc.BufferDesc.RefreshRate.Denominator = denominator;
    }
    else
    {
        swapChainDesc.BufferDesc.RefreshRate.Numerator = 0;
        swapChainDesc.BufferDesc.RefreshRate.Denominator = 1;
    }

    swapChainDesc.BufferDesc.ScanlineOrdering = DXGI_MODE_SCANLINE_ORDER_UNSPECIFIED;
    swapChainDesc.BufferDesc.Scaling = DXGI_MODE_SCALING_UNSPECIFIED;

    swapChainDesc.SwapEffect = DXGI_SWAP_EFFECT_DISCARD;

    swapChainDesc.Flags = 0;

    featureLevel = D3D_FEATURE_LEVEL_11_0;

    if (FAILED(D3D11CreateDeviceAndSwapChain(0, D3D_DRIVER_TYPE_HARDWARE, 0, 0, &featureLevel, 1, 
        D3D11_SDK_VERSION, &swapChainDesc, &m_swapChain, &m_device, 0, &m_deviceContext))) return false;

    if (FAILED(m_swapChain->GetBuffer(0, __uuidof(ID3D11Texture2D), (LPVOID*)&backBufferPtr))) return false;

    if (FAILED(m_device->CreateRenderTargetView(backBufferPtr, 0, &m_renderTargetView))) return false;

    backBufferPtr->Release();
    backBufferPtr = 0;

    memset(&depthBufferDesc, 0, sizeof(depthBufferDesc));

    depthBufferDesc.Width = screenWidth;
    depthBufferDesc.Height = screenHeight;
    depthBufferDesc.MipLevels = 1;
    depthBufferDesc.ArraySize = 1;
    depthBufferDesc.Format = DXGI_FORMAT_D24_UNORM_S8_UINT;
    depthBufferDesc.SampleDesc.Count = 1;
    depthBufferDesc.SampleDesc.Quality = 0;
    depthBufferDesc.Usage = D3D11_USAGE_DEFAULT;
    depthBufferDesc.BindFlags = D3D11_BIND_DEPTH_STENCIL;
    depthBufferDesc.CPUAccessFlags = 0;
    depthBufferDesc.MiscFlags = 0;

    if (FAILED(m_device->CreateTexture2D(&depthBufferDesc, 0, &m_depthStencilBuffer))) return false;


    memset(&depthStencilDesc, 0, sizeof(depthStencilDesc));

    depthStencilDesc.DepthEnable = true;
    depthStencilDesc.DepthWriteMask = D3D11_DEPTH_WRITE_MASK_ALL;
    depthStencilDesc.DepthFunc = D3D11_COMPARISON_LESS;

    depthStencilDesc.StencilEnable = true;
    depthStencilDesc.StencilReadMask = 0xFF;
    depthStencilDesc.StencilWriteMask = 0xFF;

    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;

    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;

    if (FAILED(m_device->CreateDepthStencilState(&depthStencilDesc, &m_depthStencilState))) return false;

    m_deviceContext->OMSetDepthStencilState(m_depthStencilState, 1);

    memset(&depthStencilViewDesc, 0, sizeof(depthStencilViewDesc));

    depthStencilViewDesc.Format = DXGI_FORMAT_D24_UNORM_S8_UINT;
    depthStencilViewDesc.ViewDimension = D3D11_DSV_DIMENSION_TEXTURE2D;
    depthStencilViewDesc.Texture2D.MipSlice = 0;


    if (FAILED(m_device->CreateDepthStencilView(m_depthStencilBuffer, &depthStencilViewDesc, &m_depthStencilView))) return false;

    m_deviceContext->OMSetRenderTargets(1, &m_renderTargetView, m_depthStencilView);

    rasterDesc.AntialiasedLineEnable = false;
    rasterDesc.CullMode = D3D11_CULL_BACK;
    rasterDesc.DepthBias = 0;
    rasterDesc.DepthBiasClamp = 0.0f;
    rasterDesc.DepthClipEnable = true;
    rasterDesc.FillMode = D3D11_FILL_SOLID;
    rasterDesc.FrontCounterClockwise = false;
    rasterDesc.MultisampleEnable = false;
    rasterDesc.ScissorEnable = true;
    rasterDesc.SlopeScaledDepthBias = 0.0f;

    if (FAILED(m_device->CreateRasterizerState(&rasterDesc, &m_rasterState))) return false;

    m_deviceContext->RSSetState(m_rasterState);

    viewport.Width = static_cast<float>(screenWidth);
    viewport.Height = static_cast<float>(screenHeight);
    viewport.MinDepth = 0.0f;
    viewport.MaxDepth = 1.0f;
    viewport.TopLeftX = 0.0f;
    viewport.TopLeftY = 0.0f;

    m_deviceContext->RSSetViewports(1, &viewport);

    fieldOfView = static_cast<float>(D3DX_PI) / 4.0f;
    screenAspect = static_cast<float>(screenWidth) / static_cast<float>(screenHeight);

    D3DXMatrixPerspectiveFovLH(&m_projectionMatrix, fieldOfView, screenAspect, screenNear, screenDepth);

    D3DXMatrixIdentity(&m_worldMatrix);

    D3DXMatrixOrthoLH(&m_orthoMatrix, static_cast<float>(screenWidth), static_cast<float>(screenHeight), screenNear, screenDepth);

    return true;
}

void D3DClass::shutdown()
{
    if (m_swapChain)
    {
        m_swapChain->SetFullscreenState(false, 0);
    }

    if (m_rasterState)
    {
        m_rasterState->Release();
        m_rasterState = 0;
    }

    if (m_depthStencilView)
    {
        m_depthStencilView->Release();
        m_depthStencilView = 0;
    }

    if (m_depthStencilState)
    {
        m_depthStencilState->Release();
        m_depthStencilState = 0;
    }

    if (m_depthStencilBuffer)
    {
        m_depthStencilBuffer->Release();
        m_depthStencilBuffer = 0;
    }

    if (m_renderTargetView)
    {
        m_renderTargetView->Release();
        m_renderTargetView = 0;
    }

    if (m_deviceContext)
    {
        m_deviceContext->Release();
        m_deviceContext = 0;
    }

    if (m_device)
    {
        m_device->Release();
        m_device = 0;
    }

    if (m_swapChain)
    {
        m_swapChain->Release();
        m_swapChain = 0;
    }
}

void D3DClass::beginScene(float red, float green, float blue, float alpha)
{
    float color[4];

    color[0] = red;
    color[1] = green;
    color[2] = blue;
    color[3] = alpha;

    m_deviceContext->ClearRenderTargetView(m_renderTargetView, color);

    m_deviceContext->ClearDepthStencilView(m_depthStencilView, D3D11_CLEAR_DEPTH, 1.0f, 0);
}

void D3DClass::endScene()
{
    if (m_vsync_enabled)
    {
        m_swapChain->Present(1, 0);
    }
    else
    {
        m_swapChain->Present(0, 0);
    }
}

ID3D11Device* D3DClass::getDevice() const
{
    return m_device;
}

ID3D11DeviceContext* D3DClass::getDeviceContext() const
{
    return m_deviceContext;
}

void D3DClass::getProjectionMatrix(D3DXMATRIX& projectionMatrix)
{
    projectionMatrix = m_projectionMatrix;
}

void D3DClass::getWorldMatrix(D3DXMATRIX& worldMatrix)
{
    worldMatrix = m_worldMatrix;
}

void D3DClass::getOrthoMatrix(D3DXMATRIX& orthoMatrix)
{
    orthoMatrix = m_orthoMatrix;
}

void D3DClass::getVideoCardInfo(char* cardName, int& memory)
{
    strcpy_s(cardName, 128, m_videoCardDescription);
    memory = m_videoCardMemory;
}

d3d.h

#ifndef D3D_H
#define D3D_H

#pragma comment(lib, "dxgi.lib")
#pragma comment(lib, "d3d11.lib")
#pragma comment(lib, "d3dx11.lib")
#pragma comment(lib, "d3dx10.lib")

#include <dxgi.h>
#include <d3dcommon.h>
#include <d3d11.h>
#include <d3dx10math.h>

class D3DClass
{
public:
    D3DClass();
    D3DClass(const D3DClass&);
    ~D3DClass();

    bool initialize(int, int, bool, HWND, bool, float, float);
    void shutdown();

    void beginScene(float, float, float, float);
    void endScene();

    ID3D11Device* getDevice() const;
    ID3D11DeviceContext* getDeviceContext() const;

    void getProjectionMatrix(D3DXMATRIX&);
    void getWorldMatrix(D3DXMATRIX&);
    void getOrthoMatrix(D3DXMATRIX&);

    void getVideoCardInfo(char*, int&);

private: 
    bool m_vsync_enabled;
    int m_videoCardMemory;
    char m_videoCardDescription[128];
    IDXGISwapChain*          m_swapChain;
    ID3D11Device*            m_device;
    ID3D11DeviceContext*     m_deviceContext;
    ID3D11RenderTargetView*  m_renderTargetView;
    ID3D11Texture2D*         m_depthStencilBuffer;
    ID3D11DepthStencilState* m_depthStencilState;
    ID3D11DepthStencilView*  m_depthStencilView;
    ID3D11RasterizerState*   m_rasterState;
    D3DXMATRIX m_projectionMatrix,
        m_worldMatrix,
        m_orthoMatrix;
};

#endif

它被调用的地方:

图形.cpp

#include "graphics.h"

GraphicsClass::GraphicsClass() : m_D3D(0)
{ }

GraphicsClass::GraphicsClass(const GraphicsClass& other)
{ }

GraphicsClass::~GraphicsClass()
{ }

bool GraphicsClass::initialize(int screenWidth, int screenHeight, HWND hwnd)
{
    m_D3D = new D3DClass;
    if (!m_D3D) return false;

    if (!(m_D3D->initialize(screenWidth, screenHeight, VSYNC_ENABLED, hwnd, FULLSCREEN, SCREEN_DEPTH, SCREEN_NEAR)))
    {
        MessageBox(hwnd, "Could not initialize DirectX", "Error", 0);
        return false;
    }

    return true;
}

bool GraphicsClass::frame()
{
    if (!render()) return false;

    return true;
}

void GraphicsClass::shutdown()
{
    if (m_D3D)
    {
        m_D3D->shutdown();
        delete m_D3D;
        m_D3D = 0;
    }
}

bool GraphicsClass::render()
{ 
    m_D3D->beginScene(0.5f, 0.5f, 0.5f, 0.0f);

    m_D3D->endScene();

    return true;
}

Answer 1

D3D11CreateDeviceAndSwapChain()来电D3DClass::initialize失败 DXGI_ERROR_INVALID_CALL .

OutputWindow 的设置值, SampleDesc和 BufferUsage在swapChainDesc变量应该可以解决问题。