mirror of
https://github.com/dolphin-emu/dolphin.git
synced 2024-11-15 13:57:57 -07:00
362 lines
15 KiB
C++
362 lines
15 KiB
C++
// Copyright 2010 Dolphin Emulator Project
|
|
// Licensed under GPLv2+
|
|
// Refer to the license.txt file included.
|
|
|
|
#include "VideoBackends/D3D/FramebufferManager.h"
|
|
|
|
#include <memory>
|
|
#include <utility>
|
|
|
|
#include "Common/CommonTypes.h"
|
|
#include "Core/HW/Memmap.h"
|
|
#include "VideoBackends/D3D/D3DBase.h"
|
|
#include "VideoBackends/D3D/D3DState.h"
|
|
#include "VideoBackends/D3D/D3DUtil.h"
|
|
#include "VideoBackends/D3D/GeometryShaderCache.h"
|
|
#include "VideoBackends/D3D/PixelShaderCache.h"
|
|
#include "VideoBackends/D3D/Render.h"
|
|
#include "VideoBackends/D3D/VertexShaderCache.h"
|
|
#include "VideoBackends/D3D/XFBEncoder.h"
|
|
#include "VideoCommon/VideoConfig.h"
|
|
|
|
namespace DX11
|
|
{
|
|
static XFBEncoder s_xfbEncoder;
|
|
static bool s_integer_efb_render_target = false;
|
|
|
|
FramebufferManager::Efb FramebufferManager::m_efb;
|
|
unsigned int FramebufferManager::m_target_width;
|
|
unsigned int FramebufferManager::m_target_height;
|
|
|
|
D3DTexture2D*& FramebufferManager::GetEFBColorTexture()
|
|
{
|
|
return m_efb.color_tex;
|
|
}
|
|
|
|
D3DTexture2D*& FramebufferManager::GetEFBColorReadTexture()
|
|
{
|
|
return m_efb.color_read_texture;
|
|
}
|
|
ID3D11Texture2D*& FramebufferManager::GetEFBColorStagingBuffer()
|
|
{
|
|
return m_efb.color_staging_buf;
|
|
}
|
|
|
|
D3DTexture2D*& FramebufferManager::GetEFBDepthTexture()
|
|
{
|
|
return m_efb.depth_tex;
|
|
}
|
|
D3DTexture2D*& FramebufferManager::GetEFBDepthReadTexture()
|
|
{
|
|
return m_efb.depth_read_texture;
|
|
}
|
|
ID3D11Texture2D*& FramebufferManager::GetEFBDepthStagingBuffer()
|
|
{
|
|
return m_efb.depth_staging_buf;
|
|
}
|
|
|
|
D3DTexture2D*& FramebufferManager::GetResolvedEFBColorTexture()
|
|
{
|
|
if (g_ActiveConfig.iMultisamples > 1)
|
|
{
|
|
for (int i = 0; i < m_efb.slices; i++)
|
|
D3D::context->ResolveSubresource(m_efb.resolved_color_tex->GetTex(),
|
|
D3D11CalcSubresource(0, i, 1), m_efb.color_tex->GetTex(),
|
|
D3D11CalcSubresource(0, i, 1), DXGI_FORMAT_R8G8B8A8_UNORM);
|
|
return m_efb.resolved_color_tex;
|
|
}
|
|
else
|
|
{
|
|
return m_efb.color_tex;
|
|
}
|
|
}
|
|
|
|
D3DTexture2D*& FramebufferManager::GetResolvedEFBDepthTexture()
|
|
{
|
|
if (g_ActiveConfig.iMultisamples > 1)
|
|
{
|
|
// ResolveSubresource does not work with depth textures.
|
|
// Instead, we use a shader that selects the minimum depth from all samples.
|
|
g_renderer->ResetAPIState();
|
|
|
|
CD3D11_VIEWPORT viewport(0.f, 0.f, (float)m_target_width, (float)m_target_height);
|
|
D3D::context->RSSetViewports(1, &viewport);
|
|
D3D::context->OMSetRenderTargets(1, &m_efb.resolved_depth_tex->GetRTV(), nullptr);
|
|
|
|
const D3D11_RECT source_rect = CD3D11_RECT(0, 0, m_target_width, m_target_height);
|
|
D3D::drawShadedTexQuad(
|
|
m_efb.depth_tex->GetSRV(), &source_rect, m_target_width, m_target_height,
|
|
PixelShaderCache::GetDepthResolveProgram(), VertexShaderCache::GetSimpleVertexShader(),
|
|
VertexShaderCache::GetSimpleInputLayout(), GeometryShaderCache::GetCopyGeometryShader());
|
|
|
|
BindEFBRenderTarget();
|
|
g_renderer->RestoreAPIState();
|
|
|
|
return m_efb.resolved_depth_tex;
|
|
}
|
|
else
|
|
{
|
|
return m_efb.depth_tex;
|
|
}
|
|
}
|
|
|
|
void FramebufferManager::SwapReinterpretTexture()
|
|
{
|
|
std::swap(m_efb.color_tex, m_efb.color_temp_tex);
|
|
std::swap(m_efb.color_int_rtv, m_efb.color_temp_int_rtv);
|
|
}
|
|
|
|
void FramebufferManager::SetIntegerEFBRenderTarget(bool enabled)
|
|
{
|
|
if (s_integer_efb_render_target == enabled)
|
|
return;
|
|
|
|
// We only use UINT render targets for logic ops, which is only supported with D3D11.1.
|
|
if (!D3D::device1)
|
|
return;
|
|
|
|
s_integer_efb_render_target = enabled;
|
|
BindEFBRenderTarget();
|
|
}
|
|
|
|
void FramebufferManager::BindEFBRenderTarget(bool bind_depth)
|
|
{
|
|
ID3D11RenderTargetView* rtv =
|
|
s_integer_efb_render_target ? m_efb.color_int_rtv : m_efb.color_tex->GetRTV();
|
|
ID3D11DepthStencilView* dsv = bind_depth ? m_efb.depth_tex->GetDSV() : nullptr;
|
|
D3D::context->OMSetRenderTargets(1, &rtv, dsv);
|
|
}
|
|
|
|
FramebufferManager::FramebufferManager(int target_width, int target_height)
|
|
{
|
|
m_target_width = static_cast<unsigned int>(std::max(target_width, 1));
|
|
m_target_height = static_cast<unsigned int>(std::max(target_height, 1));
|
|
DXGI_SAMPLE_DESC sample_desc;
|
|
sample_desc.Count = g_ActiveConfig.iMultisamples;
|
|
sample_desc.Quality = 0;
|
|
|
|
ID3D11Texture2D* buf;
|
|
D3D11_TEXTURE2D_DESC texdesc;
|
|
HRESULT hr;
|
|
|
|
m_EFBLayers = m_efb.slices = (g_ActiveConfig.iStereoMode > 0) ? 2 : 1;
|
|
|
|
// EFB color texture - primary render target
|
|
texdesc =
|
|
CD3D11_TEXTURE2D_DESC(DXGI_FORMAT_R8G8B8A8_TYPELESS, m_target_width, m_target_height,
|
|
m_efb.slices, 1, D3D11_BIND_SHADER_RESOURCE | D3D11_BIND_RENDER_TARGET,
|
|
D3D11_USAGE_DEFAULT, 0, sample_desc.Count, sample_desc.Quality);
|
|
hr = D3D::device->CreateTexture2D(&texdesc, nullptr, &buf);
|
|
CHECK(hr == S_OK, "create EFB color texture (size: %dx%d; hr=%#x)", m_target_width,
|
|
m_target_height, hr);
|
|
m_efb.color_tex = new D3DTexture2D(
|
|
buf, (D3D11_BIND_FLAG)(D3D11_BIND_SHADER_RESOURCE | D3D11_BIND_RENDER_TARGET),
|
|
DXGI_FORMAT_R8G8B8A8_UNORM, DXGI_FORMAT_UNKNOWN, DXGI_FORMAT_R8G8B8A8_UNORM,
|
|
(sample_desc.Count > 1));
|
|
|
|
SAFE_RELEASE(buf);
|
|
D3D::SetDebugObjectName(m_efb.color_tex->GetTex(), "EFB color texture");
|
|
D3D::SetDebugObjectName(m_efb.color_tex->GetSRV(), "EFB color texture shader resource view");
|
|
D3D::SetDebugObjectName(m_efb.color_tex->GetRTV(), "EFB color texture render target view");
|
|
|
|
// Temporary EFB color texture - used in ReinterpretPixelData
|
|
texdesc =
|
|
CD3D11_TEXTURE2D_DESC(DXGI_FORMAT_R8G8B8A8_TYPELESS, m_target_width, m_target_height,
|
|
m_efb.slices, 1, D3D11_BIND_SHADER_RESOURCE | D3D11_BIND_RENDER_TARGET,
|
|
D3D11_USAGE_DEFAULT, 0, sample_desc.Count, sample_desc.Quality);
|
|
hr = D3D::device->CreateTexture2D(&texdesc, nullptr, &buf);
|
|
CHECK(hr == S_OK, "create EFB color temp texture (size: %dx%d; hr=%#x)", m_target_width,
|
|
m_target_height, hr);
|
|
m_efb.color_temp_tex = new D3DTexture2D(
|
|
buf, (D3D11_BIND_FLAG)(D3D11_BIND_SHADER_RESOURCE | D3D11_BIND_RENDER_TARGET),
|
|
DXGI_FORMAT_R8G8B8A8_UNORM, DXGI_FORMAT_UNKNOWN, DXGI_FORMAT_R8G8B8A8_UNORM,
|
|
(sample_desc.Count > 1));
|
|
SAFE_RELEASE(buf);
|
|
D3D::SetDebugObjectName(m_efb.color_temp_tex->GetTex(), "EFB color temp texture");
|
|
D3D::SetDebugObjectName(m_efb.color_temp_tex->GetSRV(),
|
|
"EFB color temp texture shader resource view");
|
|
D3D::SetDebugObjectName(m_efb.color_temp_tex->GetRTV(),
|
|
"EFB color temp texture render target view");
|
|
|
|
// Integer render targets for EFB, used for logic op
|
|
CD3D11_RENDER_TARGET_VIEW_DESC int_rtv_desc(m_efb.color_tex->GetTex(),
|
|
g_ActiveConfig.iMultisamples > 1 ?
|
|
D3D11_RTV_DIMENSION_TEXTURE2DMS :
|
|
D3D11_RTV_DIMENSION_TEXTURE2D,
|
|
DXGI_FORMAT_R8G8B8A8_UINT);
|
|
hr = D3D::device->CreateRenderTargetView(m_efb.color_tex->GetTex(), &int_rtv_desc,
|
|
&m_efb.color_int_rtv);
|
|
CHECK(hr == S_OK, "create EFB integer RTV(hr=%#x)", hr);
|
|
hr = D3D::device->CreateRenderTargetView(m_efb.color_temp_tex->GetTex(), &int_rtv_desc,
|
|
&m_efb.color_temp_int_rtv);
|
|
CHECK(hr == S_OK, "create EFB integer RTV(hr=%#x)", hr);
|
|
|
|
// Render buffer for AccessEFB (color data)
|
|
texdesc = CD3D11_TEXTURE2D_DESC(DXGI_FORMAT_R8G8B8A8_UNORM, 1, 1, 1, 1, D3D11_BIND_RENDER_TARGET);
|
|
hr = D3D::device->CreateTexture2D(&texdesc, nullptr, &buf);
|
|
CHECK(hr == S_OK, "create EFB color read texture (hr=%#x)", hr);
|
|
m_efb.color_read_texture = new D3DTexture2D(buf, D3D11_BIND_RENDER_TARGET);
|
|
SAFE_RELEASE(buf);
|
|
D3D::SetDebugObjectName(m_efb.color_read_texture->GetTex(),
|
|
"EFB color read texture (used in Renderer::AccessEFB)");
|
|
D3D::SetDebugObjectName(
|
|
m_efb.color_read_texture->GetRTV(),
|
|
"EFB color read texture render target view (used in Renderer::AccessEFB)");
|
|
|
|
// AccessEFB - Sysmem buffer used to retrieve the pixel data from depth_read_texture
|
|
texdesc = CD3D11_TEXTURE2D_DESC(DXGI_FORMAT_R8G8B8A8_UNORM, 1, 1, 1, 1, 0, D3D11_USAGE_STAGING,
|
|
D3D11_CPU_ACCESS_READ);
|
|
hr = D3D::device->CreateTexture2D(&texdesc, nullptr, &m_efb.color_staging_buf);
|
|
CHECK(hr == S_OK, "create EFB color staging buffer (hr=%#x)", hr);
|
|
D3D::SetDebugObjectName(m_efb.color_staging_buf,
|
|
"EFB color staging texture (used for Renderer::AccessEFB)");
|
|
|
|
// EFB depth buffer - primary depth buffer
|
|
texdesc =
|
|
CD3D11_TEXTURE2D_DESC(DXGI_FORMAT_R32_TYPELESS, m_target_width, m_target_height, m_efb.slices,
|
|
1, D3D11_BIND_DEPTH_STENCIL | D3D11_BIND_SHADER_RESOURCE,
|
|
D3D11_USAGE_DEFAULT, 0, sample_desc.Count, sample_desc.Quality);
|
|
hr = D3D::device->CreateTexture2D(&texdesc, nullptr, &buf);
|
|
CHECK(hr == S_OK, "create EFB depth texture (size: %dx%d; hr=%#x)", m_target_width,
|
|
m_target_height, hr);
|
|
m_efb.depth_tex = new D3DTexture2D(
|
|
buf, (D3D11_BIND_FLAG)(D3D11_BIND_DEPTH_STENCIL | D3D11_BIND_SHADER_RESOURCE),
|
|
DXGI_FORMAT_R32_FLOAT, DXGI_FORMAT_D32_FLOAT, DXGI_FORMAT_UNKNOWN, (sample_desc.Count > 1));
|
|
SAFE_RELEASE(buf);
|
|
D3D::SetDebugObjectName(m_efb.depth_tex->GetTex(), "EFB depth texture");
|
|
D3D::SetDebugObjectName(m_efb.depth_tex->GetDSV(), "EFB depth texture depth stencil view");
|
|
D3D::SetDebugObjectName(m_efb.depth_tex->GetSRV(), "EFB depth texture shader resource view");
|
|
|
|
// Render buffer for AccessEFB (depth data)
|
|
texdesc = CD3D11_TEXTURE2D_DESC(DXGI_FORMAT_R32_FLOAT, 1, 1, 1, 1, D3D11_BIND_RENDER_TARGET);
|
|
hr = D3D::device->CreateTexture2D(&texdesc, nullptr, &buf);
|
|
CHECK(hr == S_OK, "create EFB depth read texture (hr=%#x)", hr);
|
|
m_efb.depth_read_texture = new D3DTexture2D(buf, D3D11_BIND_RENDER_TARGET);
|
|
SAFE_RELEASE(buf);
|
|
D3D::SetDebugObjectName(m_efb.depth_read_texture->GetTex(),
|
|
"EFB depth read texture (used in Renderer::AccessEFB)");
|
|
D3D::SetDebugObjectName(
|
|
m_efb.depth_read_texture->GetRTV(),
|
|
"EFB depth read texture render target view (used in Renderer::AccessEFB)");
|
|
|
|
// AccessEFB - Sysmem buffer used to retrieve the pixel data from depth_read_texture
|
|
texdesc = CD3D11_TEXTURE2D_DESC(DXGI_FORMAT_R32_FLOAT, 1, 1, 1, 1, 0, D3D11_USAGE_STAGING,
|
|
D3D11_CPU_ACCESS_READ);
|
|
hr = D3D::device->CreateTexture2D(&texdesc, nullptr, &m_efb.depth_staging_buf);
|
|
CHECK(hr == S_OK, "create EFB depth staging buffer (hr=%#x)", hr);
|
|
D3D::SetDebugObjectName(m_efb.depth_staging_buf,
|
|
"EFB depth staging texture (used for Renderer::AccessEFB)");
|
|
|
|
if (g_ActiveConfig.iMultisamples > 1)
|
|
{
|
|
// Framebuffer resolve textures (color+depth)
|
|
texdesc = CD3D11_TEXTURE2D_DESC(DXGI_FORMAT_R8G8B8A8_UNORM, m_target_width, m_target_height,
|
|
m_efb.slices, 1, D3D11_BIND_SHADER_RESOURCE,
|
|
D3D11_USAGE_DEFAULT, 0, 1);
|
|
hr = D3D::device->CreateTexture2D(&texdesc, nullptr, &buf);
|
|
CHECK(hr == S_OK, "create EFB color resolve texture (size: %dx%d; hr=%#x)", m_target_width,
|
|
m_target_height, hr);
|
|
m_efb.resolved_color_tex =
|
|
new D3DTexture2D(buf, D3D11_BIND_SHADER_RESOURCE, DXGI_FORMAT_R8G8B8A8_UNORM);
|
|
SAFE_RELEASE(buf);
|
|
D3D::SetDebugObjectName(m_efb.resolved_color_tex->GetTex(), "EFB color resolve texture");
|
|
D3D::SetDebugObjectName(m_efb.resolved_color_tex->GetSRV(),
|
|
"EFB color resolve texture shader resource view");
|
|
|
|
texdesc =
|
|
CD3D11_TEXTURE2D_DESC(DXGI_FORMAT_R32_FLOAT, m_target_width, m_target_height, m_efb.slices,
|
|
1, D3D11_BIND_SHADER_RESOURCE | D3D11_BIND_RENDER_TARGET);
|
|
hr = D3D::device->CreateTexture2D(&texdesc, nullptr, &buf);
|
|
CHECK(hr == S_OK, "create EFB depth resolve texture (size: %dx%d; hr=%#x)", m_target_width,
|
|
m_target_height, hr);
|
|
m_efb.resolved_depth_tex = new D3DTexture2D(
|
|
buf, (D3D11_BIND_FLAG)(D3D11_BIND_SHADER_RESOURCE | D3D11_BIND_RENDER_TARGET),
|
|
DXGI_FORMAT_R32_FLOAT, DXGI_FORMAT_UNKNOWN, DXGI_FORMAT_R32_FLOAT);
|
|
SAFE_RELEASE(buf);
|
|
D3D::SetDebugObjectName(m_efb.resolved_depth_tex->GetTex(), "EFB depth resolve texture");
|
|
D3D::SetDebugObjectName(m_efb.resolved_depth_tex->GetSRV(),
|
|
"EFB depth resolve texture shader resource view");
|
|
}
|
|
else
|
|
{
|
|
m_efb.resolved_color_tex = nullptr;
|
|
m_efb.resolved_depth_tex = nullptr;
|
|
}
|
|
|
|
s_xfbEncoder.Init();
|
|
s_integer_efb_render_target = false;
|
|
}
|
|
|
|
FramebufferManager::~FramebufferManager()
|
|
{
|
|
s_xfbEncoder.Shutdown();
|
|
|
|
SAFE_RELEASE(m_efb.color_tex);
|
|
SAFE_RELEASE(m_efb.color_int_rtv);
|
|
SAFE_RELEASE(m_efb.color_temp_tex);
|
|
SAFE_RELEASE(m_efb.color_temp_int_rtv);
|
|
SAFE_RELEASE(m_efb.color_staging_buf);
|
|
SAFE_RELEASE(m_efb.color_read_texture);
|
|
SAFE_RELEASE(m_efb.resolved_color_tex);
|
|
SAFE_RELEASE(m_efb.depth_tex);
|
|
SAFE_RELEASE(m_efb.depth_staging_buf);
|
|
SAFE_RELEASE(m_efb.depth_read_texture);
|
|
SAFE_RELEASE(m_efb.resolved_depth_tex);
|
|
}
|
|
|
|
void FramebufferManager::CopyToRealXFB(u32 xfbAddr, u32 fbStride, u32 fbHeight,
|
|
const EFBRectangle& sourceRc, float Gamma)
|
|
{
|
|
u8* dst = Memory::GetPointer(xfbAddr);
|
|
|
|
// The destination stride can differ from the copy region width, in which case the pixels
|
|
// outside the copy region should not be written to.
|
|
s_xfbEncoder.Encode(dst, static_cast<u32>(sourceRc.GetWidth()), fbHeight, sourceRc, Gamma);
|
|
}
|
|
|
|
std::unique_ptr<XFBSourceBase> FramebufferManager::CreateXFBSource(unsigned int target_width,
|
|
unsigned int target_height,
|
|
unsigned int layers)
|
|
{
|
|
return std::make_unique<XFBSource>(
|
|
D3DTexture2D::Create(target_width, target_height,
|
|
(D3D11_BIND_FLAG)(D3D11_BIND_RENDER_TARGET | D3D11_BIND_SHADER_RESOURCE),
|
|
D3D11_USAGE_DEFAULT, DXGI_FORMAT_R8G8B8A8_UNORM, 1, layers),
|
|
layers);
|
|
}
|
|
|
|
std::pair<u32, u32> FramebufferManager::GetTargetSize() const
|
|
{
|
|
return std::make_pair(m_target_width, m_target_height);
|
|
}
|
|
|
|
void XFBSource::DecodeToTexture(u32 xfbAddr, u32 fbWidth, u32 fbHeight)
|
|
{
|
|
// DX11's XFB decoder does not use this function.
|
|
// YUYV data is decoded in Render::Swap.
|
|
}
|
|
|
|
void XFBSource::CopyEFB(float Gamma)
|
|
{
|
|
g_renderer->ResetAPIState(); // reset any game specific settings
|
|
|
|
// Copy EFB data to XFB and restore render target again
|
|
const D3D11_VIEWPORT vp = CD3D11_VIEWPORT(0.f, 0.f, (float)texWidth, (float)texHeight);
|
|
const D3D11_RECT rect = CD3D11_RECT(0, 0, texWidth, texHeight);
|
|
|
|
D3D::context->RSSetViewports(1, &vp);
|
|
D3D::context->OMSetRenderTargets(1, &tex->GetRTV(), nullptr);
|
|
D3D::SetPointCopySampler();
|
|
|
|
D3D::drawShadedTexQuad(
|
|
FramebufferManager::GetEFBColorTexture()->GetSRV(), &rect, g_renderer->GetTargetWidth(),
|
|
g_renderer->GetTargetHeight(), PixelShaderCache::GetColorCopyProgram(true),
|
|
VertexShaderCache::GetSimpleVertexShader(), VertexShaderCache::GetSimpleInputLayout(),
|
|
GeometryShaderCache::GetCopyGeometryShader(), Gamma);
|
|
|
|
FramebufferManager::BindEFBRenderTarget();
|
|
g_renderer->RestoreAPIState();
|
|
}
|
|
|
|
} // namespace DX11
|