直接X 11:在屏幕上绘制一个简单的彩色矩形
Direct X 11 : Drawing A Simple Colored Rectangle On Screen
现在我知道这个问题已经被问到无数次(相同的问题，但代码不同(，我知道这很难调试现在一直在努力工作4天(这意味着我在周一或星期二早上只有3天(包括今天(提交，所以请帮助我：(。
我想要的只是在直接x 11中的屏幕上绘制一个简单的彩色正方形(我支持的功能级别是9_1(。现在我到目前为止所做的
1(检查了每个功能返回的每个hresult。即使申请终止失败。所有人都过去了!!!
2(创建了设备＆amp;在调试模式下着色器。任何地方都没有错误！
你可以看到为什么我感到沮丧。我将要在此处发布的代码可以复制＆amp;直接粘贴并没有任何问题(在Visual Studio 2017中编译，但这不是Bige(。
必须创建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(); }
}
scene.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);
}
就像我说的那样可以复制此代码＆amp;粘贴没有问题。库文件要求为d3d11.lib＆amp;d3dcompiler.lib
我不知道问题是什么或在哪里出错，但希望如果有人设法找到问题，我希望这个代码可以帮助某人以直接x 11：(。
我所得到的只是一个蓝屏，可以在全屏和窗口之间徘徊(预期输出的一半(。但是四边形不存在。
请帮助某人。谢谢。
我不知道为什么它不起作用，但是这里有一些问题。
-
在PS中，您正在使用alpha = 0返回颜色。显然，您没有设置Alpha混合，并且默认的混合状态具有alpha Blpha Blundented，但仍然是为了测试目的，请尝试输出Alpha =1.0。
-
您正在创建带有32位索引的索引缓冲区，
UINT是32位整数。但是您告诉D3D索引缓冲区包含16位索引，DXGI_FORMAT_R16_UINT。
夫妇有关代码的通用注释。
您正在运行时编译着着色器源。不。将它们脱机以获得您支持的最低功能级别(9.1？(，在运行时，从DXBC文件加载着色器。编译着色器会在您的代码中引起许多不必要的复杂性，这也需要时间。如果您使用的是VC ，请将HLSL文件包括在项目中，右键单击，属性，" HLSL编译器/常规"设置着色器类型和模型，" HLSL编译器/输出文件"在"对象文件名"中设置$(OutDir)%(Filename).cso。然后在运行时，从磁盘读取这两个.cso文件，然后致电ID3D11Device::CreateVertexShader/CreatePixelShader。
您正在为位置和颜色创建2个顶点缓冲区。一个就足够了。人们通常会在更新某些顶点属性时使用多个顶点缓冲区，但没有使用其他顶点缓冲区。当一切都像您的情况一样不变时，使用单个缓冲区更简单，更有效。定义一个包含两个字段的结构，并相应地更改输入布局。
您正在使用d3d11_create_device_debug创建设备，但显然您不会读取调试输出。使用调试器启动您的应用程序，并在Visual Studio中读取输出窗口。经常使用该标志，运行时只会打印出您的资源/着色器/州/其他涉及的其他内容。
相关文章：
- 在c++中用vector填充一个简单的动态数组
- 如何使用 samtools C API 构建一个简单的主.cpp文件
- 为什么一个简单的程序不能立即启动
- C++ - 在我尝试制作一个简单的计算器时有一个"uninitialized local variable y used"警告
- 为什么 MSVC C++编译器将一个简单的 Hello World 扩展为 4000 行汇编?
- 我写了一个简单的矢量程序，在其中我得到了以下输出。你能帮我理解它的输出吗？
- 如何使用 c++ 在命令行中创建一个简单的字符控制器?
- 对于 ~95% 写入/5% 读取线程安全的无序列图，有没有一个简单的解决方案?
- 在C++中创建一个简单的数据包路由器，如何跟踪"客户端"？
- 创建一个简单的前向迭代器，该迭代器在循环缓冲区的"end"处自动换行
- 我已经安装了用于c++编程的升华3，但在编写了一个简单的程序后，我遇到了以下错误
- 如何设置一个简单的CGAL+Qt程序
- 如何在一个简单的C++项目中使用Poco库
- 我创建了一个简单的程序，但有些地方不对劲
- Qt的新信号/时隙语法问题 - 连接到一个简单的函数
- 一个简单的 win32 多线程代码.这能行吗?
- 我正在尝试构建一个简单的程序来从 mysql 数据库中读取信息
- 创建一个简单的计算器，添加时遇到问题
- 我正在编写一个简单的客户端套接字应用程序，但在连接后服务器收到一个空缓冲区
- 为什么一个简单的"Hello World"风格的程序不能用Turbo C++编译？
