C++ 使用SpriteFont类绘制文本时出现的问题

我正在使用SpriteFont/SpriteBatch类在我的游戏中渲染文本，因为坦率地说，我已经厌倦了使用Direct2D和DirectWrite。。。但每次我用SpriteFont绘制文本时，我都会把文本写在屏幕上，但它是写在黑色背景上的。。。黑色背景挡住了我游戏的整个场景。。有没有办法去掉黑色背景，只保留文本

下面是我对SpriteFont的实现

void RenderText(int FPS)
{

std::unique_ptr<DirectX::SpriteFont> Sprite_Font(new DirectX::SpriteFont(device, L"myfile.spritefont"));

std::unique_ptr<DirectX::SpriteBatch> Sprite_Batch(new DirectX::SpriteBatch(DevContext));

Sprite_Batch->Begin();

Sprite_Font->DrawString(Sprite_Batch.get(), L"FPS: ", DirectX::XMFLOAT2(200,200));

Sprite_Batch->End();


}

每次我将背景色[4]更改为不同的值时，背景色也会相应地改变。如何从游戏中删除黑色背景并仅包含文本

这是我的全部代码

#include <Windows.h>
#include <SpriteFont.h>
#include <SpriteBatch.h>
#include <d3dcompiler.h>
#include <SimpleMath.h>

#pragma comment (lib, "dinput8.lib")
#pragma comment (lib, "D3D11.lib")
#pragma comment (lib, "d3dcompiler.lib")

LRESULT CALLBACK WindowProcedure(HWND, unsigned int, WPARAM, LPARAM);
void Create_Window(HINSTANCE&);
void Initialize_Direct3D11(HINSTANCE);
void Initialize_Rendering_Pipeline();
void Initialize_Sprites();
void Render_Frame();
void Render_Text();
void Create_Vertex_Buffer_for_triangle();

HWND MainWindow;
IDXGISwapChain * SwapChain;
ID3D11Device * device;
ID3D11DeviceContext * DevContext;
ID3D11RenderTargetView * RenderTarget;
ID3D11Buffer * VertexBuffer;
ID3D10Blob * VertexShader;
ID3D10Blob * PixelShader;
ID3D11VertexShader * VS;
ID3D11PixelShader * PS;
ID3D11InputLayout * inputLayout;
std::unique_ptr<DirectX::SpriteFont> Sprite_Font;
std::unique_ptr<DirectX::SpriteBatch> Sprite_Batch;
DirectX::SimpleMath::Vector2 m_fontPos;
const wchar_t* output = L"Hello World";


struct Vertex_Buffer
{
 float Positions[3];


Vertex_Buffer(float x, float y, float z)
{
    Positions[0] = x;
    Positions[1] = y;
    Positions[2] = z;
};

};


int WINAPI WinMain(HINSTANCE CurrentInstance, HINSTANCE PrevInstance, LPSTR ignore, int WindowShow)
{
MSG message;
HRESULT status;

Create_Window(CurrentInstance);
Initialize_Direct3D11(CurrentInstance);
Initialize_Sprites();
Initialize_Rendering_Pipeline();
Create_Vertex_Buffer_for_triangle();


while (true)
{
    if (PeekMessage(&message, MainWindow, 0, 0, PM_REMOVE))
    {
        TranslateMessage(&message);
        DispatchMessage(&message);

    }

    else
    {   
        Render_Frame();
        Render_Text();
        SwapChain->Present(0, 0);
    }

}

}

void Initialize_Sprites()
{
Sprite_Font.reset(new DirectX::SpriteFont(device, L"myfile.spritefont"));
Sprite_Batch.reset(new DirectX::SpriteBatch(DevContext));

m_fontPos.x = 200;
m_fontPos.y = 200;

}

void Create_Window(HINSTANCE &CurrentInstance)
{
WNDCLASSEX windowclass;                                 


ZeroMemory(&windowclass, sizeof(WNDCLASSEX));
windowclass.cbSize = sizeof(WNDCLASSEX);                
windowclass.lpszClassName = L"Window Class";        
windowclass.hInstance = CurrentInstance;                
windowclass.lpfnWndProc = WindowProcedure;              
windowclass.hIcon = LoadIcon(NULL, IDI_WINLOGO);        
windowclass.hCursor = LoadCursor(NULL, IDC_ARROW);      


RegisterClassEx(&windowclass);


MainWindow = CreateWindowEx(
    0,                                                  
    L"Window Class",                                    
    L"The Empire of Anatoria",                          
    WS_OVERLAPPEDWINDOW,                                
    CW_USEDEFAULT,                                      
    CW_USEDEFAULT,                                      
    800,                                                
    600,                                                
    NULL,                                               
    NULL,                                               
    CurrentInstance,                                    
    NULL                                                
    );


ShowWindow(MainWindow, SW_SHOW);
}

void Render_Text()
{
DirectX::SimpleMath::Vector2 origin = Sprite_Font->MeasureString(output);

Sprite_Batch->Begin();
Sprite_Font->DrawString(Sprite_Batch.get(), output,
    m_fontPos, DirectX::Colors::White, 0.f, origin);
Sprite_Batch->End();

}

void Initialize_Direct3D11(HINSTANCE instance) 
{
DXGI_MODE_DESC BackBufferDesc;
DXGI_SWAP_CHAIN_DESC SwapChainDesc;



ZeroMemory(&BackBufferDesc, sizeof(DXGI_MODE_DESC));
BackBufferDesc.Width = 400;                         
BackBufferDesc.Height = 400;                         
BackBufferDesc.RefreshRate.Numerator = 60;          
BackBufferDesc.RefreshRate.Denominator = 1;         
BackBufferDesc.Format = DXGI_FORMAT_R8G8B8A8_UNORM; 


ZeroMemory(&SwapChainDesc, sizeof(DXGI_SWAP_CHAIN_DESC));
SwapChainDesc.BufferDesc = BackBufferDesc;      
SwapChainDesc.BufferCount = 1;                          
SwapChainDesc.BufferUsage = DXGI_USAGE_RENDER_TARGET_OUTPUT;
SwapChainDesc.SampleDesc.Count = 1;                     
SwapChainDesc.SampleDesc.Quality = 0;                   
SwapChainDesc.OutputWindow = MainWindow;            
SwapChainDesc.Windowed = TRUE;                          
SwapChainDesc.SwapEffect = DXGI_SWAP_EFFECT_DISCARD;    



D3D11CreateDeviceAndSwapChain(NULL,                      
    D3D_DRIVER_TYPE_HARDWARE,   
    NULL,                        
    NULL,                       
    NULL,                   
    NULL,                        
    D3D11_SDK_VERSION,       
    &SwapChainDesc,          
    &SwapChain,             
    &device,                    
    NULL,                       
    &DevContext             
    );



ID3D11Texture2D * BackBuffer;
SwapChain->GetBuffer(0, __uuidof(ID3D11Texture2D), (void**)&BackBuffer);
device->CreateRenderTargetView(BackBuffer, NULL, &RenderTarget);
DevContext->OMSetRenderTargets(
            1,                            
            &RenderTarget,                  
            NULL                            
            );
BackBuffer->Release();

DevContext->IASetPrimitiveTopology(D3D11_PRIMITIVE_TOPOLOGY_TRIANGLELIST);

}

void Initialize_Rendering_Pipeline()
{
D3DCompileFromFile(L"VertexShader.hlsl", 0, 0, "main", "vs_5_0", 0, 0, &VertexShader, 0);
D3DCompileFromFile(L"VertexShader.hlsl", 0, 0, "Pixel_Shader", "ps_5_0", 0, 0, &PixelShader, 0);

device->CreateVertexShader(VertexShader->GetBufferPointer(), VertexShader->GetBufferSize(), NULL, &VS);
device->CreatePixelShader(PixelShader->GetBufferPointer(), PixelShader->GetBufferSize(), NULL, &PS);

DevContext->VSSetShader(VS, 0, 0);
DevContext->PSSetShader(PS, 0, 0);


D3D11_VIEWPORT Raster;

ZeroMemory(&Raster, sizeof(D3D11_VIEWPORT));
Raster.MinDepth = 0.0f;
Raster.MaxDepth = 1.0f;
Raster.Width = 400;
Raster.Height = 400;
DevContext->RSSetViewports(1, &Raster);



D3D11_INPUT_ELEMENT_DESC InputLayout[1];

ZeroMemory(&InputLayout[0], sizeof(D3D11_INPUT_ELEMENT_DESC));
InputLayout[0].SemanticName = "POSITION";
InputLayout[0].Format = DXGI_FORMAT_R32G32B32_FLOAT;
InputLayout[0].InputSlot = 0;
InputLayout[0].AlignedByteOffset = 0;
InputLayout[0].InputSlotClass = D3D11_INPUT_PER_VERTEX_DATA;

device->CreateInputLayout(
    InputLayout,
    1,
    VertexShader->GetBufferPointer(),
    VertexShader->GetBufferSize(),
    &inputLayout
    );
DevContext->IASetInputLayout(inputLayout);
}

void Render_Frame()
{
float BackgroundColor[4] = {0.0f, 0.0f, 0.0f, 1.0f};

DevContext->ClearRenderTargetView(RenderTarget, BackgroundColor);

DevContext->Draw(3, 0);

}

void Create_Vertex_Buffer_for_triangle()
{
D3D11_BUFFER_DESC VertexBufferDesc;
D3D11_SUBRESOURCE_DATA VertexData;
UINT stride = sizeof(Vertex_Buffer);
UINT offset = 0;

ZeroMemory(&VertexBufferDesc, sizeof(D3D11_BUFFER_DESC));
VertexBufferDesc.Usage = D3D11_USAGE_DEFAULT;
VertexBufferDesc.BindFlags = D3D11_BIND_VERTEX_BUFFER;
VertexBufferDesc.CPUAccessFlags = 0;
VertexBufferDesc.ByteWidth = sizeof(Vertex_Buffer) * 3;


Vertex_Buffer VerticesData[] =
{
    Vertex_Buffer(0.0f, 0.5f, 0.5f),
    Vertex_Buffer(0.5f, -0.5f, 0.5f),
    Vertex_Buffer(-0.5f, -0.5f, 0.5f)
};


ZeroMemory(&VertexData, sizeof(D3D11_SUBRESOURCE_DATA));
VertexData.pSysMem = VerticesData;

device->CreateBuffer(
    &VertexBufferDesc,
    &VertexData,
    &VertexBuffer);

DevContext->IASetVertexBuffers(
    0,
    1,
    &VertexBuffer,
    &stride,
    &offset
    );

}

LRESULT CALLBACK WindowProcedure(HWND handle, unsigned int message, WPARAM ignore1, LPARAM ignore2)
{
switch (message)
{

case WM_CREATE:
    return 0;


case WM_CLOSE:
    DestroyWindow(handle);
    return 0;


default:
    return DefWindowProc(handle, message, ignore1, ignore2);
}


}

---

首先，如果您的代码片段是准确的，那么您不应该每帧都创建

SpriteFont

和

SpriteBatch

实例。您只需在设备更改时创建它们

默认情况下，

SpriteFont

使用预乘alpha混合模式进行绘制，因此，如果您得到的是完全“背景色”的图像，则管道状态中会出现其他问题。很可能是在“清除”和“渲染文本”（RenderText）之间的渲染中保留了一些有效状态，这些状态会影响应重置的“渲染器”（SpriteBatch）

它也可能是用于背景清晰的颜色，其alpha设置为0而不是1。尝试使用：

float BackgroundColor[4] = { 0.0f, 0.0f, 0.0f, 1.0f };

试着通过以下几个步骤来确保事情是独立工作的，这样您就可以理解这些类是如何工作的

---

你和我在

SpriteFont

上有同样的问题。调用

SpriteFont

后，我们忘记重置

VertexBuffer

s和所有其他渲染状态。请参阅我的帖子和Chuck Walbourn的解决方案：

引用恰克的话：

您可以在InitScene中设置场景的渲染状态，但绘制任何其他内容都会更改状态，而SpriteBatch正是这样做的。我在一个文档中陈述了DirectX工具箱中的每个对象在wiki上的操作。您需要设置绘制所需的每个帧的所有状态，而不是假设它是永久设置的，如果您进行了多个绘制

---

有关提供更多信息的其他链接，请参见我的问题。

尝试使用调用

开始
进行sprite批处理，并使用
AlphaBlend
进行混合状态（或者可能是
非预乘
）。只是一个猜测——这不在我的范围之内，但我正在翻阅文档，试图寻找一种透明的绘图模式。我已经尝试设置混合状态以使背景透明，但仍然不起作用。背景仍然挡住了整个场景。还有其他建议吗？抱歉，这是我唯一的建议。我从未使用过这个API，但我希望有人会注意到这个线程并加入。VertexShader.hlsl
文件来自哪里？它似乎包含了顶点和像素着色器，但可能没有，因为调用
D3DCompileFromFile
时没有任何错误检查。我去了教程，我想我对这些类有了更好的理解。但是我有一个问题，我应该什么时候重置
SpriteBatch
和
SpriteFont
实例？我应该在游戏循环中重置它们吗？在“设备丢失”场景中，您应该只需要
reset（）
std:：unique\u ptr

（即

Present

返回

DXGI\u ERROR\u DEVICE\u REMOVED

或

DXGI\u ERROR\u DEVICE\u RESET

，这意味着设备无效，必须丢弃基于Direct3D设备的所有内容，并使用新的设备实例重新创建）.仔细看这节课。我遵循了教程中的每一步，但黑色背景依然存在。我甚至制作了一个新应用程序，只画了一个红色三角形，一旦我制作了精灵，黑色背景就覆盖了三角形。我在我的原始帖子中包含了我的新应用程序的代码，如果你有空闲时间，你能复制专业版吗问题？您应该对代码做的第一件事是确保检查所有返回一个函数的

HRESULT

返回：

HRESULT hr=/*Direct3D函数*/；if（失败（hr））/*error*/

上面的代码段基本上没有错误检查，因此在出现错误时不会收到通知。其次，您需要通过将

D3D11\u CREATE\u device\u debug

作为第四个参数传递给

D3D11CreateDevice和SwapChain

，来启用Direct3D调试设备。请参阅。

float4 main( float4 pos : POSITION ) : SV_POSITION
{
return pos;
}

float4 Pixel_Shader() : SV_TARGET
{
return float4(1.0f, 0.0f, 0.0f, 1.0f);
}

float BackgroundColor[4] = { 0.0f, 0.0f, 0.0f, 1.0f };