Direct X 11：在屏幕上绘制一个简单的彩色矩形

Question

现在我知道这个问题已经被问过无数次了（同样的问题，但代码不同），我知道这很难调试，但这是一个从现在开始 1 周到期的家庭作业，我现在已经为此苦苦挣扎了 4 天（这意味着我只剩下 3 天，包括今天）周一或周二早上最多提交，所以请帮帮我:(。

我想要的只是直接在 x 11 的屏幕上绘制一个简单的彩色方块（我支持的功能级别是 9_1）。现在我已经做了什么

1) 检查每个函数返回的每个 HRESULT。即使一个失败，应用程序也会终止。 都过了！！！

2) 在调试模式下创建设备和着色器。任何地方都没有错误！

你明白我为什么沮丧。我即将在此处发布的代码可以直接复制和粘贴，并且可以毫无问题地运行（在 Visual Studio 2017 中编译，但这没什么大不了的）。

必须创建6个文件

1)DirectX.h
2)DirectX.cpp
3)Scene.h
4)Scene.cpp
5)VShader.hlsl
6)PShader.hlsl

现在是代码

DirectX.h

#ifndef DIRECTX_H
#define DIRECTX_H

#include "stdafx.h"
#include <d3d11.h>

class D3D11Device
{
 private:
 D3D11_TEXTURE2D_DESC depthStencilDesc;
 ID3D11Device* device;
 ID3D11DeviceContext* context;
 IDXGISwapChain* swapChain;

 private:
 ID3D11RenderTargetView* target;
 ID3D11DepthStencilView* buffer;
 ID3D11RasterizerState*  rState;

 private:
 int errors;
 D3D11Device(HWND, int, int);


 public:
 static D3D11Device* Create(HWND, int, int);
 void bindTargets();
 int resize(int, int);
 ID3D11Device* getDevice();
 ID3D11DeviceContext* getContext();
 void clear(float,float,float,float);
 void present();
 ~D3D11Device();
};

#endif DIRECTX_H

DirectX.cpp

 #include "stdafx.h"
    #include "DirectX.h"

    D3D11Device::D3D11Device(HWND window,int w,int h)
    {
     errors = 0;
     device = nullptr;
     context = nullptr;
     swapChain = nullptr;
     rState = nullptr;
     target = nullptr;
     buffer = nullptr;
     D3D_FEATURE_LEVEL level = {};

     D3D_FEATURE_LEVEL levels[] = {
           D3D_FEATURE_LEVEL_9_1,
           D3D_FEATURE_LEVEL_9_2,
           D3D_FEATURE_LEVEL_9_3,
           D3D_FEATURE_LEVEL_10_0,
           D3D_FEATURE_LEVEL_10_1,
           D3D_FEATURE_LEVEL_11_0,
           D3D_FEATURE_LEVEL_11_1
        };


     //CREATE DEVICE AND CONTEXT
     HRESULT hr = D3D11CreateDevice(nullptr,D3D_DRIVER_TYPE_HARDWARE,0,D3D11_CREATE_DEVICE_BGRA_SUPPORT | D3D11_CREATE_DEVICE_DEBUG
                                   ,levels,ARRAYSIZE(levels),D3D11_SDK_VERSION
                                   ,&device,&level,&context);
     if (FAILED(hr))
     {
      MessageBox(NULL, L"Failed To Create Device And Context", L"Failed D3D Init", MB_OK);
      errors = 1;
      return;
     }






     //CREATE SWAP CHAIN
     DXGI_SWAP_CHAIN_DESC desc = {};

     desc.Windowed = TRUE;
     desc.OutputWindow = window;
     desc.SwapEffect = DXGI_SWAP_EFFECT_FLIP_DISCARD;
     desc.Flags = DXGI_SWAP_CHAIN_FLAG_ALLOW_MODE_SWITCH;

     desc.BufferCount = 2;
     desc.BufferDesc.Format = DXGI_FORMAT_B8G8R8A8_UNORM;
     desc.BufferDesc.Width = w;
     desc.BufferDesc.Height = h;
     desc.BufferUsage = DXGI_USAGE_RENDER_TARGET_OUTPUT;

     desc.SampleDesc.Count=1;
     desc.SampleDesc.Quality = 0;


     IDXGIDevice* dxgidevice =nullptr;
     IDXGIAdapter* adapter=nullptr;
     IDXGIFactory* factory=nullptr;
     if (FAILED(device->QueryInterface(__uuidof(IDXGIDevice), (void**)&dxgidevice)))
     {
      MessageBox(NULL, L"Failed To Get DXGI Device", L"Failed D3D Init", MB_OK);
      errors = 1;
      return;
     }
     if (FAILED(dxgidevice->GetParent(__uuidof(IDXGIAdapter), (void**)&adapter)))
     {
      MessageBox(NULL, L"Failed To Get DXGI Adapter", L"Failed D3D Init", MB_OK);
      errors = 1;
      return;
     }
     if (FAILED(adapter->GetParent(__uuidof(IDXGIFactory), (void**)&factory)))
     {
      MessageBox(NULL, L"Failed To Get DXGI Factory", L"Failed D3D Init", MB_OK);
      errors = 1;
      return;
     }
     if (FAILED(factory->CreateSwapChain(device, &desc, &swapChain)))
     {
      MessageBox(NULL, L"Failed To Create Swap Chain", L"Failed Swap Chain", MB_OK);
      errors = 1;
      return;
     }
     dxgidevice->Release();
     adapter->Release();
     factory->Release();






     //CREATING RENDER TARGET AND DEPTH&STENCIL BUFFER
     ID3D11Texture2D* texture;

     if (FAILED(swapChain->GetBuffer(0, __uuidof(ID3D11Texture2D), (void**)&texture)))
     {
      MessageBox(NULL, L"Failed To Aquire Back Buffer", L"Failed D3D Init", MB_OK);
      errors = 1;
      return;
     }
     if (FAILED(device->CreateRenderTargetView(texture, NULL, &target)))
     {
      MessageBox(NULL, L"Failed To Create Render Target", L"Failed D3D Init", MB_OK);
      errors = 1;
      return;
     }
     texture->Release();


     depthStencilDesc = {};

     depthStencilDesc.Width = w;
     depthStencilDesc.Height = h;
     depthStencilDesc.ArraySize = 1;
     depthStencilDesc.MipLevels = 1;

     depthStencilDesc.Format = DXGI_FORMAT_D24_UNORM_S8_UINT;
     depthStencilDesc.Usage = D3D11_USAGE_DEFAULT;
     depthStencilDesc.BindFlags = D3D11_BIND_DEPTH_STENCIL;

     depthStencilDesc.SampleDesc.Count = 1;
     depthStencilDesc.SampleDesc.Quality = 0;
     depthStencilDesc.CPUAccessFlags = 0;
     depthStencilDesc.MiscFlags = 0;

     if (FAILED(device->CreateTexture2D(&depthStencilDesc, NULL, &texture)))
     {
      MessageBox(NULL, L"Failed To Create DepthStencil Texture", L"Failed D3D Init", MB_OK);
      errors = 1;
      return;
     }
     if (FAILED(device->CreateDepthStencilView(texture, 0, &buffer)))
     {
      MessageBox(NULL, L"Failed To Create DepthStencil Buffer", L"Failed D3D Init", MB_OK);
      errors = 1;
      return;
     }
     texture->Release();





     //SET RASTERIZER STATE
     D3D11_RASTERIZER_DESC rDesc = {};
     rDesc.CullMode = D3D11_CULL_NONE;
     rDesc.FillMode = D3D11_FILL_SOLID;
     rDesc.FrontCounterClockwise = true;
     rDesc.DepthClipEnable = true;
     if (FAILED(device->CreateRasterizerState(&rDesc, &rState)))
     {
      MessageBox(NULL, L"Failed To Create Rasterizer State", L"Failed Rasterizer State", MB_OK);
      errors = 1;
      return;
     }
     context->RSSetState(rState);





     //SET VIEW PORT
     D3D11_VIEWPORT viewPort = {};
     viewPort.TopLeftX=0;
     viewPort.TopLeftY=0;
     viewPort.Width =(float)w;
     viewPort.Height =(float)h;
     viewPort.MinDepth = 0.0f;
     viewPort.MaxDepth = 1.0f;
     context->RSSetViewports(1, &viewPort);
    }

    D3D11Device* D3D11Device::Create(HWND parent,int w,int h)
    {
     D3D11Device* directx = new D3D11Device(parent,w,h);
     if (directx->errors == 1)
     {
      delete directx;
      directx = nullptr;
     }
     return directx;
    }

    int D3D11Device::resize(int width,int height)
    {
     target->Release();
     buffer->Release();
     target = nullptr;
     buffer = nullptr;

     context->OMSetRenderTargets(0, nullptr, nullptr);
     context->Flush();
     if (FAILED(swapChain->ResizeBuffers(2, width, height, DXGI_FORMAT_UNKNOWN, 0)))
     {
      MessageBox(NULL, L"Failed To Resize Buffers", L"Failed Resize", MB_OK);
      return -1;
     }


     ID3D11Texture2D* texture=nullptr;

     if (FAILED(swapChain->GetBuffer(0, __uuidof(ID3D11Texture2D), (void**)&texture)))
     {
      MessageBox(NULL, L"Failed To Aquire Back Buffer", L"Failed D3D Init", MB_OK);
      return -1;
     }
     if (FAILED(device->CreateRenderTargetView(texture, NULL, &target)))
     {
      MessageBox(NULL, L"Failed To Create Render Target", L"Failed D3D Init", MB_OK);
      return -1;
     }
     texture->Release();
     texture = nullptr;



     depthStencilDesc.Width = width;
     depthStencilDesc.Height = height;
     if (FAILED(device->CreateTexture2D(&depthStencilDesc, NULL, &texture)))
     {
      MessageBox(NULL, L"Failed To Create DepthStencil Texture", L"Failed D3D Init", MB_OK);
      return -1;
     }
     if (FAILED(device->CreateDepthStencilView(texture, 0, &buffer)))
     {
      MessageBox(NULL, L"Failed To Create DepthStencil Buffer", L"Failed D3D Init", MB_OK);
      return -1;
     }
     texture->Release();
     texture = nullptr;


     D3D11_VIEWPORT viewPort = {};
     viewPort.TopLeftX = 0;
     viewPort.TopLeftY = 0;
     viewPort.Width =(float)width;
     viewPort.Height =(float)height;
     viewPort.MinDepth = 0.0f;
     viewPort.MaxDepth = 1.0f;
     context->RSSetViewports(1, &viewPort);

     return 1;
    }

    ID3D11Device* D3D11Device::getDevice() { return device; }
    ID3D11DeviceContext* D3D11Device::getContext() { return context; }

    void D3D11Device::bindTargets() { context->OMSetRenderTargets(1, &target, buffer); }
    void D3D11Device::clear(float r, float g, float b, float a)
    {
     float color[4] = { r,g,b,a };
     context->ClearRenderTargetView(target, color);
 context->ClearDepthStencilView(buffer, D3D11_CLEAR_DEPTH |D3D11_CLEAR_STENCIL,0, 0);
    }
    void D3D11Device::present() { swapChain->Present(0,0); }

    D3D11Device::~D3D11Device()
    {
     if (rState != nullptr) { rState->Release(); }
     if (target != nullptr) { target->Release(); }
     if (buffer != nullptr) { buffer->Release(); }

     if (swapChain != nullptr)
     {
      swapChain->SetFullscreenState(FALSE,NULL);
      swapChain->Release();
     }
     if (device != nullptr) { device->Release(); }
     if (context != nullptr) { context->Release(); }
    }

场景.h

#ifndef SCENE_H
#define SCENE_H

#include "stdafx.h"
#include "DirectX.h"
#include <atlstr.h>
#include <d3dcompiler.h>
#include <DirectXMath.h>

class Scene;

class Window
{
 private:
 HWND window;
 Scene* scene;
 int errors;

 private:
 Window(HINSTANCE, int, int, int, int);
 static LRESULT CALLBACK winProc(HWND, UINT, WPARAM, LPARAM);

 public:
 static Window* Create(HINSTANCE, int, int, int, int);
 void display(int);
 Scene* getScene();
 ~Window();
};

struct ShaderInfo
{
 LPCWSTR vFile;
 LPCSTR  vEntry;
 LPCSTR  vVersion;

 LPCWSTR pFile;
 LPCSTR  pEntry;
 LPCSTR  pVersion;
 ID3DInclude* pIncludes;
};

class Include : public ID3DInclude
{
 private:
 ID3DBlob* blob;

 public:
 HRESULT _stdcall Open(D3D_INCLUDE_TYPE, LPCSTR, LPCVOID, LPCVOID*, UINT*);
 HRESULT _stdcall Close(LPCVOID);
};

class RasterShader
{
 private:
 int errors;
 ID3D11InputLayout* inputLayout;
 ID3D11VertexShader* vShader;
 ID3D11PixelShader*  pShader;

 private:
 RasterShader(ID3D11Device*,ShaderInfo*);
 HRESULT Compile(LPCWSTR,LPCSTR,LPCSTR,ID3DInclude*,ID3DBlob**);

 public:
 static RasterShader* Create(ID3D11Device*,ShaderInfo*);
 void render(ID3D11DeviceContext*);
 ~RasterShader();
};

class QuadGeometry
{
 private:
 int errors;
 ID3D11Buffer* vertexBuffer;
 ID3D11Buffer* colorBuffer;
 ID3D11Buffer* indexBuffer;

 private:
 QuadGeometry(ID3D11Device*);
 HRESULT createBuffer(ID3D11Device* device,UINT,D3D11_SUBRESOURCE_DATA*,int,ID3D11Buffer**);

 public:
 static QuadGeometry* Create(ID3D11Device*);
 void render(ID3D11DeviceContext*);
 ~QuadGeometry();
};

class Scene
{
 private:
 int errors;
 D3D11Device* directx;
 RasterShader* shader;
 QuadGeometry* geometry;

 private:
 Scene(HWND,int,int);

 public:
 static Scene* Create(HWND,int,int);
 void render();
 int resize(int, int);
 ~Scene();
};

#endif SCENE_H

场景.cpp

#include "stdafx.h"
#include "Scene.h"

Window::Window(HINSTANCE app, int x, int y, int w, int h)
{
 errors = 0;

 WNDCLASSEX wClass = {};
 wClass.cbSize = sizeof(WNDCLASSEX);
 wClass.hInstance = app;
 wClass.lpszClassName = L"Window";
 wClass.lpfnWndProc = winProc;
 if (!RegisterClassEx(&wClass))
 {
  MessageBox(NULL, L"Failed To Register Window Class", L"Window Class", MB_OK);
  errors = 1;
  return;
 }

 window = CreateWindowEx(WS_EX_CLIENTEDGE, L"Window", L"Direct X", WS_OVERLAPPEDWINDOW
                        ,x, y, w, h
                        ,NULL, 0, app, this);
 if(!window)
 {
  MessageBox(NULL, L"Failed To Create Window", L"Window", MB_OK);
  errors = 1; 
 }
}

LRESULT Window::winProc(HWND parent, UINT msg, WPARAM high, LPARAM low)
{
 if (msg == WM_CREATE)
 {
  LPCREATESTRUCT create = (LPCREATESTRUCT)(low);
  Window* thisClass = (Window*)create->lpCreateParams;

  RECT rect = {};
  GetWindowRect(parent, &rect);
  thisClass->scene = Scene::Create(parent, rect.right - rect.left, rect.bottom - rect.top);
  if (thisClass->scene == nullptr) { return -1; }

  SetWindowLongPtr(parent, GWLP_USERDATA, (LONGLONG)thisClass);
  return 1;
 }
 else if (msg == WM_SIZE)
 {
  Window* window = (Window*)GetWindowLongPtr(parent, GWLP_USERDATA);
  int newWidth = (int)LOWORD(low);
  int newHeight = (int)HIWORD(low);
  return window->scene->resize(newWidth,newHeight);
 }
 else if (msg == WM_CLOSE)
 {
  DestroyWindow(parent);
  return 1;
 }
 else if (msg == WM_DESTROY)
 {
  PostQuitMessage(0);
  return 1;
 }
 return DefWindowProc(parent, msg, high, low);
}

Window* Window::Create(HINSTANCE app, int x, int y, int w, int h)
{
 Window* window = new Window(app, x, y, w, h);
 if (window->errors == 1)
 {
  delete window;
  window = nullptr;
 }
 return window;
}

void Window::display(int code) { ShowWindow(window, code); }
Scene* Window::getScene() { return scene; }
Window::~Window()
{
 if (scene != nullptr) { delete scene; }
 UnregisterClass(L"Window", GetModuleHandle(NULL));
}













HRESULT Include::Open
(
    D3D_INCLUDE_TYPE IncludeType,
    LPCSTR           pFileName,
    LPCVOID          pParentData,
    LPCVOID          *ppData,
    UINT             *pBytes
)
{
 CString D(pFileName);
 if (FAILED(D3DReadFileToBlob(D.GetBuffer(), &blob)))
 {
  CString fileName(pFileName);
  MessageBox(NULL, L"Failed To Load File", fileName.GetBuffer(), MB_OK);
  fileName.ReleaseBuffer();
  return D3D10_ERROR_FILE_NOT_FOUND;
 }
 D.ReleaseBuffer();

 (*ppData) = blob->GetBufferPointer();
 (*pBytes) = blob->GetBufferSize();

 return S_OK;
}

HRESULT Include::Close(LPCVOID data) 
{
 blob->Release();
 return S_OK; 
}


RasterShader::RasterShader(ID3D11Device* device,ShaderInfo* info)
{
 ID3DBlob* compiledCode=nullptr;
 inputLayout = nullptr;
 vShader = nullptr;
 pShader = nullptr;
 errors = 0;

 if (FAILED(Compile(info->vFile,info->vEntry,info->vVersion,nullptr,&compiledCode)))
 {
  errors = 1;
  return;
 }
 if (FAILED(device->CreateVertexShader(compiledCode->GetBufferPointer(), compiledCode->GetBufferSize(),nullptr, &vShader)))
 {
  compiledCode->Release();
  MessageBox(NULL, L"Failed To Create Vertex Shader", L"Failed Vertex Shader", MB_OK);
  errors = 1;
  return;
 }

 D3D11_INPUT_ELEMENT_DESC desc[] =
 {
   {"POSITION",0,DXGI_FORMAT_R32G32_FLOAT,0,0,D3D11_INPUT_PER_VERTEX_DATA,0}
  ,{"COLOR",0,DXGI_FORMAT_R32G32B32_FLOAT,1,0,D3D11_INPUT_PER_VERTEX_DATA,0}
 };
 if (FAILED(device->CreateInputLayout(desc,2,compiledCode->GetBufferPointer(),compiledCode->GetBufferSize(),&inputLayout)))
 {
  compiledCode->Release();
  MessageBox(NULL, L"Failed To Create Input Layout", L"Failed Input Layout", MB_OK);
  errors = 1;
  return;
 }
 compiledCode->Release();
 compiledCode = nullptr;


 if (FAILED(Compile(info->pFile, info->pEntry, info->pVersion,info->pIncludes,&compiledCode)))
 {
  errors = 1;
  return;
 }
 if (FAILED(device->CreatePixelShader(compiledCode->GetBufferPointer(), compiledCode->GetBufferSize(), nullptr, &pShader)))
 {
  compiledCode->Release();
  MessageBox(NULL, L"Failed To Create Pixel Shader", L"Failed Pixel Shader", MB_OK);
  errors = 1;
  return;
 }
 compiledCode->Release();
 compiledCode = nullptr;
}

HRESULT RasterShader::Compile(LPCWSTR fileName,LPCSTR entry,LPCSTR version,ID3DInclude* include,ID3DBlob** code)
{
 ID3DBlob* errors=nullptr;
 HRESULT hr = D3DCompileFromFile(fileName,nullptr,include
                                ,entry,version
                                ,D3DCOMPILE_WARNINGS_ARE_ERRORS,0,code,&errors);
 if (FAILED(hr))
 {
  if (errors!=nullptr)
  {
   CString data((char*)errors->GetBufferPointer());
   MessageBox(NULL, data.GetBuffer(),fileName, MB_OK);

   data.ReleaseBuffer();
   errors->Release();
  }
 }
 return hr;
}

RasterShader * RasterShader::Create(ID3D11Device* device,ShaderInfo* info)
{
 RasterShader* shader = new RasterShader(device,info);
 if (shader->errors == 1)
 {
  delete shader;
  shader = nullptr;
 }
 return shader;
}

void RasterShader::render(ID3D11DeviceContext* context)
{
 context->IASetInputLayout(inputLayout);
 context->VSSetShader(vShader, nullptr, 0);
 context->PSSetShader(pShader, nullptr, 0);
}

RasterShader::~RasterShader()
{
 if (inputLayout != nullptr) { inputLayout->Release(); }
 if (vShader != nullptr) { vShader->Release(); }
 if (pShader != nullptr) { pShader->Release(); }
}













QuadGeometry::QuadGeometry(ID3D11Device* device)
{
 errors = 0;
 vertexBuffer = nullptr;
 colorBuffer = nullptr;
 indexBuffer = nullptr;
 D3D11_SUBRESOURCE_DATA Data = {};


 DirectX::XMFLOAT2 verts[]=
 {
   DirectX::XMFLOAT2(0.5f,0.5f)
  ,DirectX::XMFLOAT2(-0.5f,0.5f)
  ,DirectX::XMFLOAT2(-0.5f,-0.5f)
  ,DirectX::XMFLOAT2(0.5f,-0.5f)
 };
 Data.pSysMem = verts;
 Data.SysMemPitch = 0;
 Data.SysMemSlicePitch = 0;
 if(FAILED(createBuffer(device, D3D11_BIND_VERTEX_BUFFER,&Data,sizeof(DirectX::XMFLOAT2) * 4,&vertexBuffer)))
 {
  MessageBox(NULL, L"Failed To Create Vertex Buffer", L"Failed Vertex Buffer", MB_OK);
  errors = 1;
  return;
 }

 DirectX::XMFLOAT3 colors[] =
 {
   DirectX::XMFLOAT3(1,0,0)
  ,DirectX::XMFLOAT3(0,1,0)
  ,DirectX::XMFLOAT3(1,0,1)
  ,DirectX::XMFLOAT3(1,1,0)
 };
 Data.pSysMem = colors;
 Data.SysMemPitch = 0;
 Data.SysMemSlicePitch = 0;
 if (FAILED(createBuffer(device, D3D11_BIND_VERTEX_BUFFER,&Data, sizeof(DirectX::XMFLOAT3) * 4, &colorBuffer)))
 {
  MessageBox(NULL, L"Failed To Create Color Buffer", L"Failed Color Buffer", MB_OK);
  errors = 1;
  return;
 }

 UINT indices[]=
 {
   0,1,2
  ,0,2,3
 };
 Data.pSysMem = indices;
 Data.SysMemPitch = 0;
 Data.SysMemSlicePitch = 0;
 if (FAILED(createBuffer(device, D3D11_BIND_INDEX_BUFFER, &Data, sizeof(UINT) * 6, &indexBuffer)))
 {
  MessageBox(NULL, L"Failed To Create Index Buffer", L"Failed Index Buffer", MB_OK);
  errors = 1;
  return;
 }
}

HRESULT QuadGeometry::createBuffer(ID3D11Device* device,UINT bind,D3D11_SUBRESOURCE_DATA* data,int byteSize,ID3D11Buffer** buffer)
{
 D3D11_BUFFER_DESC desc = {};
 desc.BindFlags = bind;
 desc.ByteWidth = byteSize;
 desc.Usage = D3D11_USAGE_IMMUTABLE;
 desc.CPUAccessFlags = 0;
 desc.MiscFlags = 0;
 desc.StructureByteStride = 0;

 return device->CreateBuffer(&desc,data,buffer);
}

QuadGeometry * QuadGeometry::Create(ID3D11Device* device)
{
 QuadGeometry* geom = new QuadGeometry(device);
 if (geom->errors == 1)
 {
  delete geom;
  geom = nullptr;
 }
 return geom;
}

void QuadGeometry::render(ID3D11DeviceContext* context)
{
 UINT strides[] = { sizeof(DirectX::XMFLOAT2),sizeof(DirectX::XMFLOAT3)};
 UINT offsets[] = { 0,0 };
 ID3D11Buffer* buffers[] = {vertexBuffer,colorBuffer};

 context->IASetVertexBuffers(0, 2, buffers, strides, offsets);
 context->IASetIndexBuffer(indexBuffer,DXGI_FORMAT_R16_UINT, 0);
 context->IASetPrimitiveTopology(D3D11_PRIMITIVE_TOPOLOGY_TRIANGLELIST);

 context->DrawIndexed(6, 0, 0);
}

QuadGeometry::~QuadGeometry()
{
 if (vertexBuffer != nullptr) { vertexBuffer->Release(); }
 if (colorBuffer != nullptr) { colorBuffer->Release(); }
 if (indexBuffer != nullptr) { indexBuffer->Release(); }
}











Scene::Scene(HWND window, int w, int h)
{
 errors = 0;
 directx = nullptr;
 shader = nullptr;
 geometry = nullptr;

 directx = D3D11Device::Create(window, w, h);
 if (directx == nullptr)
 {
  errors = 1;
  return;
 }

 ShaderInfo info = {};
 info.vFile = L"VShader.hlsl";
 info.vEntry = "VShader";
 info.vVersion = "vs_4_0_level_9_1";
 info.pFile = L"PShader.hlsl";
 info.pEntry = "PShader";
 info.pVersion = "ps_4_0_level_9_1";
 info.pIncludes = (ID3DInclude*)new Include();
 shader = RasterShader::Create(directx->getDevice(), &info);
 if (shader == nullptr)
 {
  errors = 1;
  return;
 }

 geometry = QuadGeometry::Create(directx->getDevice());
 if (geometry == nullptr){errors = 1;}
}

Scene * Scene::Create(HWND window, int w, int h)
{
 Scene* scene = new Scene(window, w, h);
 if (scene->errors == 1)
 {
  delete scene;
  scene = nullptr;
 }
 return scene;
}

void Scene::render()
{
 directx->clear(0, 0, 0.5f, 0);

 directx->bindTargets();
 shader->render(directx->getContext());
 geometry->render(directx->getContext());

 directx->present();
}

int Scene::resize(int w, int h) { return directx->resize(w, h); }

Scene::~Scene()
{
 if (shader != nullptr) { delete shader; }
 if (geometry != nullptr) { delete geometry; }
 if (directx != nullptr) { delete directx; }
}

VShader.hlsl

struct VIn
{
 float2 position: POSITION;
 float3 color   : COLOR;
};

struct VOut
{
 float4 pos : SV_POSITION;
 float3 clr :     COLOR;
};

VOut VShader(in VIn input)
{
 VOut output;

 output.pos = float4(input.position.x,input.position.y,0,1.0f);
 output.clr = input.color;

 return output;
}

PShader.hlsl

# include "VShader.hlsl"

float4 PShader(in VOut input) : SV_TARGET
{
  return float4(1,0,1,0);
}

就像我说的，这段代码可以毫无问题地复制和粘贴。库文件需要 d3d11.lib & d3dcompiler.lib

我不知道问题是什么或哪里出错了，但希望如果有人确实找到了问题，我希望这段代码可以帮助那里的人开始使用直接 x 11 :)。

我得到的只是一个可以在全屏和窗口之间切换的蓝屏（预期输出的一半）。但四边形不存在。

请帮助某人。谢谢你。

Answer 1

我不知道为什么它不起作用，但我看到了一些问题。

1234563 1.0.

1. 您正在使用 32 位索引创建索引缓冲区，UINT 是 32 位整数。然而你告诉 D3D 索引缓冲区包含 16 位索引，DXGI_FORMAT_R16_UINT。

关于代码的几个一般说明。

您正在运行时编译着色器源代码。别。离线编译它们以获得您支持的最低功能级别（9.1？），并在运行时从 DXBC 文件加载着色器。编译着色器会给你的代码带来很多不必要的复杂性，而且还需要时间。如果你使用VC++，在工程中包含hlsl文件，右键，属性，“HLSL Compiler / General”设置着色器类型和模型，“HLSL Compiler / Output Files”在“Object File Name”设置$(OutDir)%(Filename).cso .然后在运行时，从磁盘读取这两个.cso文件，并调用ID3D11Device::CreateVertexShader/CreatePixelShader。

您正在为位置和颜色创建 2 个顶点缓冲区。一个就够了。人们通常在更新某些顶点属性而不更新其他顶点属性时使用多个顶点缓冲区。当一切都像您的情况一样不可变时，使用单个缓冲区更简单，更有效。定义一个包含两个字段的结构，并相应地更改输入布局。

您正在使用 D3D11_CREATE_DEVICE_DEBUG 创建设备，但显然您没有读取调试输出。使用调试器启动您的应用程序，并在 Visual Studio 中读取输出窗口。使用该标志，运行时通常只会打印您的资源/着色器/状态/所涉及的任何其他问题。