summaryrefslogtreecommitdiff
path: root/Source/Core/VideoBackends/D3D/Render.cpp
diff options
context:
space:
mode:
authorStenzek <stenzek@gmail.com>2019-02-15 11:59:50 +1000
committerStenzek <stenzek@gmail.com>2019-02-19 16:57:54 +1000
commitf039149198657c1891e1c6462ed30c31ed4b8486 (patch)
treeb914fd7b0ef9c937e9334a880a49a26a26f17c8f /Source/Core/VideoBackends/D3D/Render.cpp
parent933f3ba008942cba96ed623c25e61d6ea86582fe (diff)
Move most backend functionality to VideoCommon
Diffstat (limited to 'Source/Core/VideoBackends/D3D/Render.cpp')
-rw-r--r--Source/Core/VideoBackends/D3D/Render.cpp651
1 files changed, 113 insertions, 538 deletions
diff --git a/Source/Core/VideoBackends/D3D/Render.cpp b/Source/Core/VideoBackends/D3D/Render.cpp
index 2a82924708..a172425e3f 100644
--- a/Source/Core/VideoBackends/D3D/Render.cpp
+++ b/Source/Core/VideoBackends/D3D/Render.cpp
@@ -23,33 +23,19 @@
#include "VideoBackends/D3D/BoundingBox.h"
#include "VideoBackends/D3D/D3DBase.h"
#include "VideoBackends/D3D/D3DState.h"
-#include "VideoBackends/D3D/D3DUtil.h"
#include "VideoBackends/D3D/DXPipeline.h"
#include "VideoBackends/D3D/DXShader.h"
#include "VideoBackends/D3D/DXTexture.h"
-#include "VideoBackends/D3D/FramebufferManager.h"
-#include "VideoBackends/D3D/GeometryShaderCache.h"
-#include "VideoBackends/D3D/PixelShaderCache.h"
-#include "VideoBackends/D3D/TextureCache.h"
-#include "VideoBackends/D3D/VertexShaderCache.h"
#include "VideoCommon/BPFunctions.h"
-#include "VideoCommon/OnScreenDisplay.h"
-#include "VideoCommon/PixelEngine.h"
+#include "VideoCommon/FramebufferManager.h"
+#include "VideoCommon/PostProcessing.h"
#include "VideoCommon/RenderState.h"
-#include "VideoCommon/VideoBackendBase.h"
-#include "VideoCommon/VideoCommon.h"
#include "VideoCommon/VideoConfig.h"
#include "VideoCommon/XFMemory.h"
namespace DX11
{
-// Reserve 512KB for vertices, and 64KB for uniforms.
-// This should be sufficient for our usages, and if more is required,
-// we split it into multiple draws.
-constexpr u32 UTILITY_VBO_SIZE = 512 * 1024;
-constexpr u32 UTILITY_UBO_SIZE = 64 * 1024;
-
// Nvidia stereo blitting struct defined in "nvstereo.h" from the Nvidia SDK
typedef struct _Nv_Stereo_Image_Header
{
@@ -67,119 +53,10 @@ Renderer::Renderer(int backbuffer_width, int backbuffer_height, float backbuffer
AbstractTextureFormat::RGBA8)
{
m_last_fullscreen_state = D3D::GetFullscreenState();
- g_framebuffer_manager = std::make_unique<FramebufferManager>(m_target_width, m_target_height);
- SetupDeviceObjects();
-
- D3D11_VIEWPORT vp = CD3D11_VIEWPORT(0.f, 0.f, (float)m_target_width, (float)m_target_height);
- D3D::context->RSSetViewports(1, &vp);
- FramebufferManager::BindEFBRenderTarget();
- m_current_framebuffer_width = m_target_width;
- m_current_framebuffer_height = m_target_height;
-}
-
-Renderer::~Renderer()
-{
- TeardownDeviceObjects();
-}
-
-void Renderer::SetupDeviceObjects()
-{
- HRESULT hr;
-
- D3D11_DEPTH_STENCIL_DESC ddesc;
- ddesc.DepthEnable = FALSE;
- ddesc.DepthWriteMask = D3D11_DEPTH_WRITE_MASK_ZERO;
- ddesc.DepthFunc = D3D11_COMPARISON_ALWAYS;
- ddesc.StencilEnable = FALSE;
- ddesc.StencilReadMask = D3D11_DEFAULT_STENCIL_READ_MASK;
- ddesc.StencilWriteMask = D3D11_DEFAULT_STENCIL_WRITE_MASK;
- hr = D3D::device->CreateDepthStencilState(&ddesc, &m_clear_depth_states[0]);
- CHECK(hr == S_OK, "Create depth state for Renderer::ClearScreen");
- ddesc.DepthWriteMask = D3D11_DEPTH_WRITE_MASK_ALL;
- ddesc.DepthEnable = TRUE;
- hr = D3D::device->CreateDepthStencilState(&ddesc, &m_clear_depth_states[1]);
- CHECK(hr == S_OK, "Create depth state for Renderer::ClearScreen");
- ddesc.DepthWriteMask = D3D11_DEPTH_WRITE_MASK_ZERO;
- hr = D3D::device->CreateDepthStencilState(&ddesc, &m_clear_depth_states[2]);
- CHECK(hr == S_OK, "Create depth state for Renderer::ClearScreen");
- D3D::SetDebugObjectName(m_clear_depth_states[0],
- "depth state for Renderer::ClearScreen (depth buffer disabled)");
- D3D::SetDebugObjectName(
- m_clear_depth_states[1],
- "depth state for Renderer::ClearScreen (depth buffer enabled, writing enabled)");
- D3D::SetDebugObjectName(
- m_clear_depth_states[2],
- "depth state for Renderer::ClearScreen (depth buffer enabled, writing disabled)");
-
- D3D11_BLEND_DESC blenddesc;
- blenddesc.AlphaToCoverageEnable = FALSE;
- blenddesc.IndependentBlendEnable = FALSE;
- blenddesc.RenderTarget[0].BlendEnable = FALSE;
- blenddesc.RenderTarget[0].RenderTargetWriteMask = D3D11_COLOR_WRITE_ENABLE_ALL;
- blenddesc.RenderTarget[0].SrcBlend = D3D11_BLEND_ONE;
- blenddesc.RenderTarget[0].DestBlend = D3D11_BLEND_ZERO;
- blenddesc.RenderTarget[0].BlendOp = D3D11_BLEND_OP_ADD;
- blenddesc.RenderTarget[0].SrcBlendAlpha = D3D11_BLEND_ONE;
- blenddesc.RenderTarget[0].DestBlendAlpha = D3D11_BLEND_ZERO;
- blenddesc.RenderTarget[0].BlendOpAlpha = D3D11_BLEND_OP_ADD;
- hr = D3D::device->CreateBlendState(&blenddesc, &m_reset_blend_state);
- CHECK(hr == S_OK, "Create blend state for Renderer::ResetAPIState");
- D3D::SetDebugObjectName(m_reset_blend_state, "blend state for Renderer::ResetAPIState");
-
- m_clear_blend_states[0] = m_reset_blend_state;
- m_reset_blend_state->AddRef();
-
- blenddesc.RenderTarget[0].RenderTargetWriteMask =
- D3D11_COLOR_WRITE_ENABLE_RED | D3D11_COLOR_WRITE_ENABLE_GREEN | D3D11_COLOR_WRITE_ENABLE_BLUE;
- hr = D3D::device->CreateBlendState(&blenddesc, &m_clear_blend_states[1]);
- CHECK(hr == S_OK, "Create blend state for Renderer::ClearScreen");
-
- blenddesc.RenderTarget[0].RenderTargetWriteMask = D3D11_COLOR_WRITE_ENABLE_ALPHA;
- hr = D3D::device->CreateBlendState(&blenddesc, &m_clear_blend_states[2]);
- CHECK(hr == S_OK, "Create blend state for Renderer::ClearScreen");
-
- blenddesc.RenderTarget[0].RenderTargetWriteMask = 0;
- hr = D3D::device->CreateBlendState(&blenddesc, &m_clear_blend_states[3]);
- CHECK(hr == S_OK, "Create blend state for Renderer::ClearScreen");
-
- ddesc.DepthEnable = FALSE;
- ddesc.DepthWriteMask = D3D11_DEPTH_WRITE_MASK_ZERO;
- ddesc.DepthFunc = D3D11_COMPARISON_LESS;
- ddesc.StencilEnable = FALSE;
- ddesc.StencilReadMask = D3D11_DEFAULT_STENCIL_READ_MASK;
- ddesc.StencilWriteMask = D3D11_DEFAULT_STENCIL_WRITE_MASK;
- hr = D3D::device->CreateDepthStencilState(&ddesc, &m_reset_depth_state);
- CHECK(hr == S_OK, "Create depth state for Renderer::ResetAPIState");
- D3D::SetDebugObjectName(m_reset_depth_state, "depth stencil state for Renderer::ResetAPIState");
-
- D3D11_RASTERIZER_DESC rastdesc = CD3D11_RASTERIZER_DESC(D3D11_FILL_SOLID, D3D11_CULL_NONE, false,
- 0, 0.f, 0.f, false, false, false, false);
- hr = D3D::device->CreateRasterizerState(&rastdesc, &m_reset_rast_state);
- CHECK(hr == S_OK, "Create rasterizer state for Renderer::ResetAPIState");
- D3D::SetDebugObjectName(m_reset_rast_state, "rasterizer state for Renderer::ResetAPIState");
-
- m_screenshot_texture = nullptr;
-}
-
-// Kill off all device objects
-void Renderer::TeardownDeviceObjects()
-{
- g_framebuffer_manager.reset();
-
- SAFE_RELEASE(m_clear_blend_states[0]);
- SAFE_RELEASE(m_clear_blend_states[1]);
- SAFE_RELEASE(m_clear_blend_states[2]);
- SAFE_RELEASE(m_clear_blend_states[3]);
- SAFE_RELEASE(m_clear_depth_states[0]);
- SAFE_RELEASE(m_clear_depth_states[1]);
- SAFE_RELEASE(m_clear_depth_states[2]);
- SAFE_RELEASE(m_reset_blend_state);
- SAFE_RELEASE(m_reset_depth_state);
- SAFE_RELEASE(m_reset_rast_state);
- SAFE_RELEASE(m_screenshot_texture);
- SAFE_RELEASE(m_3d_vision_texture);
}
+Renderer::~Renderer() = default;
+
void Renderer::Create3DVisionTexture(int width, int height)
{
// Create a staging texture for 3D vision with signature information in the last row.
@@ -200,9 +77,17 @@ void Renderer::Create3DVisionTexture(int width, int height)
sys_data.SysMemPitch = pitch;
sys_data.pSysMem = memory.get();
- m_3d_vision_texture =
- D3DTexture2D::Create(width * 2, height + 1, D3D11_BIND_RENDER_TARGET, D3D11_USAGE_DEFAULT,
- DXGI_FORMAT_R8G8B8A8_UNORM, 1, 1, &sys_data);
+ CD3D11_TEXTURE2D_DESC texture_desc(DXGI_FORMAT_R8G8B8A8_UNORM, width * 2, height + 1, 1, 1,
+ D3D11_BIND_RENDER_TARGET, D3D11_USAGE_DEFAULT, 0, 1, 0, 0);
+ ID3D11Texture2D* texture;
+ HRESULT hr = D3D::device->CreateTexture2D(&texture_desc, &sys_data, &texture);
+ CHECK(SUCCEEDED(hr), "Create 3D Vision Texture");
+ m_3d_vision_texture = std::make_unique<DXTexture>(TextureConfig(width * 2, height + 1, 1, 1, 1,
+ AbstractTextureFormat::RGBA8,
+ AbstractTextureFlag_RenderTarget),
+ texture, nullptr, nullptr);
+ m_3d_vision_framebuffer =
+ DXFramebuffer::Create(static_cast<DXTexture*>(m_3d_vision_texture.get()), nullptr);
}
bool Renderer::IsHeadless() const
@@ -212,7 +97,7 @@ bool Renderer::IsHeadless() const
std::unique_ptr<AbstractTexture> Renderer::CreateTexture(const TextureConfig& config)
{
- return std::make_unique<DXTexture>(config);
+ return DXTexture::Create(config);
}
std::unique_ptr<AbstractStagingTexture> Renderer::CreateStagingTexture(StagingTextureType type,
@@ -221,12 +106,11 @@ std::unique_ptr<AbstractStagingTexture> Renderer::CreateStagingTexture(StagingTe
return DXStagingTexture::Create(type, config);
}
-std::unique_ptr<AbstractFramebuffer>
-Renderer::CreateFramebuffer(const AbstractTexture* color_attachment,
- const AbstractTexture* depth_attachment)
+std::unique_ptr<AbstractFramebuffer> Renderer::CreateFramebuffer(AbstractTexture* color_attachment,
+ AbstractTexture* depth_attachment)
{
- return DXFramebuffer::Create(static_cast<const DXTexture*>(color_attachment),
- static_cast<const DXTexture*>(depth_attachment));
+ return DXFramebuffer::Create(static_cast<DXTexture*>(color_attachment),
+ static_cast<DXTexture*>(depth_attachment));
}
std::unique_ptr<AbstractShader> Renderer::CreateShaderFromSource(ShaderStage stage,
@@ -249,220 +133,44 @@ std::unique_ptr<AbstractPipeline> Renderer::CreatePipeline(const AbstractPipelin
void Renderer::SetPipeline(const AbstractPipeline* pipeline)
{
const DXPipeline* dx_pipeline = static_cast<const DXPipeline*>(pipeline);
- if (!dx_pipeline)
+ if (m_current_pipeline == dx_pipeline)
return;
- D3D::stateman->SetRasterizerState(dx_pipeline->GetRasterizerState());
- D3D::stateman->SetDepthState(dx_pipeline->GetDepthState());
- D3D::stateman->SetBlendState(dx_pipeline->GetBlendState());
- D3D::stateman->SetPrimitiveTopology(dx_pipeline->GetPrimitiveTopology());
- D3D::stateman->SetInputLayout(dx_pipeline->GetInputLayout());
- D3D::stateman->SetVertexShader(dx_pipeline->GetVertexShader());
- D3D::stateman->SetGeometryShader(dx_pipeline->GetGeometryShader());
- D3D::stateman->SetPixelShader(dx_pipeline->GetPixelShader());
-}
-
-TargetRectangle Renderer::ConvertEFBRectangle(const EFBRectangle& rc)
-{
- TargetRectangle result;
- result.left = EFBToScaledX(rc.left);
- result.top = EFBToScaledY(rc.top);
- result.right = EFBToScaledX(rc.right);
- result.bottom = EFBToScaledY(rc.bottom);
- return result;
-}
-
-void Renderer::SetScissorRect(const MathUtil::Rectangle<int>& rc)
-{
- const RECT rect = {rc.left, rc.top, rc.right, rc.bottom};
- D3D::context->RSSetScissorRects(1, &rect);
-}
-
-// This function allows the CPU to directly access the EFB.
-// There are EFB peeks (which will read the color or depth of a pixel)
-// and EFB pokes (which will change the color or depth of a pixel).
-//
-// The behavior of EFB peeks can only be modified by:
-// - GX_PokeAlphaRead
-// The behavior of EFB pokes can be modified by:
-// - GX_PokeAlphaMode (TODO)
-// - GX_PokeAlphaUpdate (TODO)
-// - GX_PokeBlendMode (TODO)
-// - GX_PokeColorUpdate (TODO)
-// - GX_PokeDither (TODO)
-// - GX_PokeDstAlpha (TODO)
-// - GX_PokeZMode (TODO)
-u32 Renderer::AccessEFB(EFBAccessType type, u32 x, u32 y, u32 poke_data)
-{
- // Convert EFB dimensions to the ones of our render target
- EFBRectangle efbPixelRc;
- efbPixelRc.left = x;
- efbPixelRc.top = y;
- efbPixelRc.right = x + 1;
- efbPixelRc.bottom = y + 1;
- TargetRectangle targetPixelRc = Renderer::ConvertEFBRectangle(efbPixelRc);
-
- // Take the mean of the resulting dimensions; TODO: Don't use the center pixel, compute the
- // average color instead
- D3D11_RECT RectToLock;
- if (type == EFBAccessType::PeekColor || type == EFBAccessType::PeekZ)
- {
- RectToLock.left = (targetPixelRc.left + targetPixelRc.right) / 2;
- RectToLock.top = (targetPixelRc.top + targetPixelRc.bottom) / 2;
- RectToLock.right = RectToLock.left + 1;
- RectToLock.bottom = RectToLock.top + 1;
- }
- else
- {
- RectToLock.left = targetPixelRc.left;
- RectToLock.right = targetPixelRc.right;
- RectToLock.top = targetPixelRc.top;
- RectToLock.bottom = targetPixelRc.bottom;
- }
-
- // Reset any game specific settings.
- ResetAPIState();
- D3D11_VIEWPORT vp = CD3D11_VIEWPORT(0.f, 0.f, 1.f, 1.f);
- D3D::context->RSSetViewports(1, &vp);
- D3D::SetPointCopySampler();
-
- // Select copy and read textures depending on if we are doing a color or depth read (since they
- // are different formats).
- D3DTexture2D* source_tex;
- D3DTexture2D* read_tex;
- ID3D11Texture2D* staging_tex;
- if (type == EFBAccessType::PeekColor)
- {
- source_tex = FramebufferManager::GetEFBColorTexture();
- read_tex = FramebufferManager::GetEFBColorReadTexture();
- staging_tex = FramebufferManager::GetEFBColorStagingBuffer();
- }
- else
+ if (dx_pipeline)
{
- source_tex = FramebufferManager::GetEFBDepthTexture();
- read_tex = FramebufferManager::GetEFBDepthReadTexture();
- staging_tex = FramebufferManager::GetEFBDepthStagingBuffer();
+ D3D::stateman->SetRasterizerState(dx_pipeline->GetRasterizerState());
+ D3D::stateman->SetDepthState(dx_pipeline->GetDepthState());
+ D3D::stateman->SetBlendState(dx_pipeline->GetBlendState());
+ D3D::stateman->SetPrimitiveTopology(dx_pipeline->GetPrimitiveTopology());
+ D3D::stateman->SetInputLayout(dx_pipeline->GetInputLayout());
+ D3D::stateman->SetVertexShader(dx_pipeline->GetVertexShader());
+ D3D::stateman->SetGeometryShader(dx_pipeline->GetGeometryShader());
+ D3D::stateman->SetPixelShader(dx_pipeline->GetPixelShader());
+ D3D::stateman->SetIntegerRTV(dx_pipeline->UseLogicOp());
}
-
- // Select pixel shader (we don't want to average depth samples, instead select the minimum).
- ID3D11PixelShader* copy_pixel_shader;
- if (type == EFBAccessType::PeekZ && g_ActiveConfig.iMultisamples > 1)
- copy_pixel_shader = PixelShaderCache::GetDepthResolveProgram();
else
- copy_pixel_shader = PixelShaderCache::GetColorCopyProgram(true);
-
- // Draw a quad to grab the texel we want to read.
- D3D::context->OMSetRenderTargets(1, &read_tex->GetRTV(), nullptr);
- D3D::drawShadedTexQuad(source_tex->GetSRV(), &RectToLock, Renderer::GetTargetWidth(),
- Renderer::GetTargetHeight(), copy_pixel_shader,
- VertexShaderCache::GetSimpleVertexShader(),
- VertexShaderCache::GetSimpleInputLayout());
-
- // Restore expected game state.
- RestoreAPIState();
-
- // Copy the pixel from the renderable to cpu-readable buffer.
- D3D11_BOX box = CD3D11_BOX(0, 0, 0, 1, 1, 1);
- D3D::context->CopySubresourceRegion(staging_tex, 0, 0, 0, 0, read_tex->GetTex(), 0, &box);
- D3D11_MAPPED_SUBRESOURCE map;
- CHECK(D3D::context->Map(staging_tex, 0, D3D11_MAP_READ, 0, &map) == S_OK,
- "Map staging buffer failed");
-
- // Convert the framebuffer data to the format the game is expecting to receive.
- u32 ret;
- if (type == EFBAccessType::PeekColor)
{
- u32 val;
- memcpy(&val, map.pData, sizeof(val));
-
- // our buffers are RGBA, yet a BGRA value is expected
- val = ((val & 0xFF00FF00) | ((val >> 16) & 0xFF) | ((val << 16) & 0xFF0000));
-
- // check what to do with the alpha channel (GX_PokeAlphaRead)
- PixelEngine::UPEAlphaReadReg alpha_read_mode = PixelEngine::GetAlphaReadMode();
-
- if (bpmem.zcontrol.pixel_format == PEControl::RGBA6_Z24)
- {
- val = RGBA8ToRGBA6ToRGBA8(val);
- }
- else if (bpmem.zcontrol.pixel_format == PEControl::RGB565_Z16)
- {
- val = RGBA8ToRGB565ToRGBA8(val);
- }
- if (bpmem.zcontrol.pixel_format != PEControl::RGBA6_Z24)
- {
- val |= 0xFF000000;
- }
-
- if (alpha_read_mode.ReadMode == 2)
- ret = val; // GX_READ_NONE
- else if (alpha_read_mode.ReadMode == 1)
- ret = (val | 0xFF000000); // GX_READ_FF
- else /*if(alpha_read_mode.ReadMode == 0)*/
- ret = (val & 0x00FFFFFF); // GX_READ_00
+ // These will be destroyed at pipeline destruction.
+ D3D::stateman->SetInputLayout(nullptr);
+ D3D::stateman->SetVertexShader(nullptr);
+ D3D::stateman->SetGeometryShader(nullptr);
+ D3D::stateman->SetPixelShader(nullptr);
}
- else // type == EFBAccessType::PeekZ
- {
- float val;
- memcpy(&val, map.pData, sizeof(val));
-
- // depth buffer is inverted in the d3d backend
- val = 1.0f - val;
-
- if (bpmem.zcontrol.pixel_format == PEControl::RGB565_Z16)
- {
- // if Z is in 16 bit format you must return a 16 bit integer
- ret = MathUtil::Clamp<u32>(static_cast<u32>(val * 65536.0f), 0, 0xFFFF);
- }
- else
- {
- ret = MathUtil::Clamp<u32>(static_cast<u32>(val * 16777216.0f), 0, 0xFFFFFF);
- }
- }
-
- D3D::context->Unmap(staging_tex, 0);
- return ret;
}
-void Renderer::PokeEFB(EFBAccessType type, const EfbPokeData* points, size_t num_points)
+void Renderer::SetScissorRect(const MathUtil::Rectangle<int>& rc)
{
- ResetAPIState();
-
- if (type == EFBAccessType::PokeColor)
- {
- D3D11_VIEWPORT vp =
- CD3D11_VIEWPORT(0.0f, 0.0f, (float)GetTargetWidth(), (float)GetTargetHeight());
- D3D::context->RSSetViewports(1, &vp);
- }
- else // if (type == EFBAccessType::PokeZ)
- {
- D3D::stateman->SetBlendState(m_clear_blend_states[3]);
- D3D::stateman->SetDepthState(m_clear_depth_states[1]);
-
- D3D11_VIEWPORT vp =
- CD3D11_VIEWPORT(0.0f, 0.0f, (float)GetTargetWidth(), (float)GetTargetHeight());
-
- D3D::context->RSSetViewports(1, &vp);
- }
-
- D3D::DrawEFBPokeQuads(type, points, num_points);
-
- RestoreAPIState();
+ // TODO: Move to stateman
+ const CD3D11_RECT rect(rc.left, rc.top, std::max(rc.right, rc.left + 1),
+ std::max(rc.bottom, rc.top + 1));
+ D3D::context->RSSetScissorRects(1, &rect);
}
void Renderer::SetViewport(float x, float y, float width, float height, float near_depth,
float far_depth)
{
- // In D3D, the viewport rectangle must fit within the render target.
- D3D11_VIEWPORT vp;
- vp.TopLeftX = MathUtil::Clamp(x, 0.0f, static_cast<float>(m_current_framebuffer_width - 1));
- vp.TopLeftY = MathUtil::Clamp(y, 0.0f, static_cast<float>(m_current_framebuffer_height - 1));
- vp.Width =
- MathUtil::Clamp(width, 1.0f, static_cast<float>(m_current_framebuffer_width) - vp.TopLeftX);
- vp.Height =
- MathUtil::Clamp(height, 1.0f, static_cast<float>(m_current_framebuffer_height) - vp.TopLeftY);
- vp.MinDepth = near_depth;
- vp.MaxDepth = far_depth;
+ // TODO: Move to stateman
+ const CD3D11_VIEWPORT vp(x, y, width, height, near_depth, far_depth);
D3D::context->RSSetViewports(1, &vp);
}
@@ -478,89 +186,19 @@ void Renderer::DrawIndexed(u32 base_index, u32 num_indices, u32 base_vertex)
D3D::context->DrawIndexed(num_indices, base_index, base_vertex);
}
-void Renderer::ClearScreen(const EFBRectangle& rc, bool colorEnable, bool alphaEnable, bool zEnable,
- u32 color, u32 z)
-{
- ResetAPIState();
-
- if (colorEnable && alphaEnable)
- D3D::stateman->SetBlendState(m_clear_blend_states[0]);
- else if (colorEnable)
- D3D::stateman->SetBlendState(m_clear_blend_states[1]);
- else if (alphaEnable)
- D3D::stateman->SetBlendState(m_clear_blend_states[2]);
- else
- D3D::stateman->SetBlendState(m_clear_blend_states[3]);
-
- // TODO: Should we enable Z testing here?
- // if (!bpmem.zmode.testenable) D3D::stateman->PushDepthState(s_clear_depth_states[0]);
- // else
- if (zEnable)
- D3D::stateman->SetDepthState(m_clear_depth_states[1]);
- else /*if (!zEnable)*/
- D3D::stateman->SetDepthState(m_clear_depth_states[2]);
-
- // Update the view port for clearing the picture
- TargetRectangle targetRc = Renderer::ConvertEFBRectangle(rc);
- D3D11_VIEWPORT vp =
- CD3D11_VIEWPORT((float)targetRc.left, (float)targetRc.top, (float)targetRc.GetWidth(),
- (float)targetRc.GetHeight(), 0.f, 1.f);
- D3D::context->RSSetViewports(1, &vp);
- FramebufferManager::SetIntegerEFBRenderTarget(false);
-
- // Color is passed in bgra mode so we need to convert it to rgba
- u32 rgbaColor = (color & 0xFF00FF00) | ((color >> 16) & 0xFF) | ((color << 16) & 0xFF0000);
- D3D::drawClearQuad(rgbaColor, 1.0f - (z & 0xFFFFFF) / 16777216.0f);
-
- RestoreAPIState();
-}
-
-void Renderer::ReinterpretPixelData(unsigned int convtype)
+void Renderer::DispatchComputeShader(const AbstractShader* shader, u32 groups_x, u32 groups_y,
+ u32 groups_z)
{
- // TODO: MSAA support..
- D3D11_RECT source = CD3D11_RECT(0, 0, GetTargetWidth(), GetTargetHeight());
-
- ID3D11PixelShader* pixel_shader;
- if (convtype == 0)
- pixel_shader = PixelShaderCache::ReinterpRGB8ToRGBA6(true);
- else if (convtype == 2)
- pixel_shader = PixelShaderCache::ReinterpRGBA6ToRGB8(true);
- else
- {
- ERROR_LOG(VIDEO, "Trying to reinterpret pixel data with unsupported conversion type %d",
- convtype);
- return;
- }
-
- // convert data and set the target texture as our new EFB
- ResetAPIState();
-
- D3D11_VIEWPORT vp = CD3D11_VIEWPORT(0.f, 0.f, static_cast<float>(GetTargetWidth()),
- static_cast<float>(GetTargetHeight()));
- D3D::context->RSSetViewports(1, &vp);
-
- D3D::context->OMSetRenderTargets(1, &FramebufferManager::GetEFBColorTempTexture()->GetRTV(),
- nullptr);
- D3D::SetPointCopySampler();
- D3D::drawShadedTexQuad(
- FramebufferManager::GetEFBColorTexture()->GetSRV(), &source, GetTargetWidth(),
- GetTargetHeight(), pixel_shader, VertexShaderCache::GetSimpleVertexShader(),
- VertexShaderCache::GetSimpleInputLayout(), GeometryShaderCache::GetCopyGeometryShader());
-
- FramebufferManager::SwapReinterpretTexture();
- RestoreAPIState();
+ D3D::stateman->SetComputeShader(static_cast<const DXShader*>(shader)->GetD3DComputeShader());
+ D3D::stateman->SyncComputeBindings();
+ D3D::context->Dispatch(groups_x, groups_y, groups_z);
}
void Renderer::BindBackbuffer(const ClearColor& clear_color)
{
CheckForSurfaceChange();
CheckForSurfaceResize();
-
- D3D::context->OMSetRenderTargets(1, &D3D::GetBackBuffer()->GetRTV(), nullptr);
- D3D::context->ClearRenderTargetView(D3D::GetBackBuffer()->GetRTV(), clear_color.data());
- m_current_framebuffer = nullptr;
- m_current_framebuffer_width = m_backbuffer_width;
- m_current_framebuffer_height = m_backbuffer_height;
+ SetAndClearFramebuffer(D3D::GetSwapChainFramebuffer(), clear_color);
}
void Renderer::PresentBackbuffer()
@@ -570,14 +208,6 @@ void Renderer::PresentBackbuffer()
void Renderer::OnConfigChanged(u32 bits)
{
- // Resize the back buffers NOW to avoid flickering
- if (bits & (CONFIG_CHANGE_BIT_TARGET_SIZE | CONFIG_CHANGE_BIT_MULTISAMPLES |
- CONFIG_CHANGE_BIT_STEREO_MODE))
- {
- PixelShaderCache::InvalidateMSAAShaders();
- g_framebuffer_manager.reset();
- g_framebuffer_manager = std::make_unique<FramebufferManager>(m_target_width, m_target_height);
- }
}
void Renderer::CheckForSurfaceChange()
@@ -585,8 +215,8 @@ void Renderer::CheckForSurfaceChange()
if (!m_surface_changed.TestAndClear())
return;
- SAFE_RELEASE(m_screenshot_texture);
- SAFE_RELEASE(m_3d_vision_texture);
+ m_3d_vision_framebuffer.reset();
+ m_3d_vision_texture.reset();
D3D::Reset(reinterpret_cast<HWND>(m_new_surface_handle));
m_new_surface_handle = nullptr;
@@ -601,8 +231,9 @@ void Renderer::CheckForSurfaceResize()
if (!m_surface_resized.TestAndClear() && !exclusive_fullscreen_changed)
return;
- SAFE_RELEASE(m_screenshot_texture);
- SAFE_RELEASE(m_3d_vision_texture);
+ m_3d_vision_framebuffer.reset();
+ m_3d_vision_texture.reset();
+
m_last_fullscreen_state = fullscreen_state;
if (D3D::swapchain)
D3D::ResizeSwapChain();
@@ -625,43 +256,38 @@ void Renderer::UpdateBackbufferSize()
}
}
-// ALWAYS call RestoreAPIState for each ResetAPIState call you're doing
-void Renderer::ResetAPIState()
+void Renderer::SetFramebuffer(AbstractFramebuffer* framebuffer)
{
- D3D::stateman->SetBlendState(m_reset_blend_state);
- D3D::stateman->SetDepthState(m_reset_depth_state);
- D3D::stateman->SetRasterizerState(m_reset_rast_state);
-}
+ if (m_current_framebuffer == framebuffer)
+ return;
-void Renderer::RestoreAPIState()
-{
- // Gets us back into a more game-like state.
- m_current_framebuffer = nullptr;
- m_current_framebuffer_width = m_target_width;
- m_current_framebuffer_height = m_target_height;
- FramebufferManager::BindEFBRenderTarget();
- BPFunctions::SetViewport();
- BPFunctions::SetScissor();
-}
+ // We can't leave the framebuffer bound as a texture and a render target.
+ DXFramebuffer* fb = static_cast<DXFramebuffer*>(framebuffer);
+ if ((fb->GetColorAttachment() &&
+ D3D::stateman->UnsetTexture(
+ static_cast<DXTexture*>(fb->GetColorAttachment())->GetD3DSRV()) != 0) ||
+ (fb->GetDepthAttachment() &&
+ D3D::stateman->UnsetTexture(
+ static_cast<DXTexture*>(fb->GetDepthAttachment())->GetD3DSRV()) != 0))
+ {
+ D3D::stateman->ApplyTextures();
+ }
-void Renderer::SetFramebuffer(const AbstractFramebuffer* framebuffer)
-{
- const DXFramebuffer* fb = static_cast<const DXFramebuffer*>(framebuffer);
- D3D::context->OMSetRenderTargets(fb->GetNumRTVs(), fb->GetRTVArray(), fb->GetDSV());
+ D3D::stateman->SetFramebuffer(fb);
m_current_framebuffer = fb;
- m_current_framebuffer_width = fb->GetWidth();
- m_current_framebuffer_height = fb->GetHeight();
}
-void Renderer::SetAndDiscardFramebuffer(const AbstractFramebuffer* framebuffer)
+void Renderer::SetAndDiscardFramebuffer(AbstractFramebuffer* framebuffer)
{
SetFramebuffer(framebuffer);
}
-void Renderer::SetAndClearFramebuffer(const AbstractFramebuffer* framebuffer,
+void Renderer::SetAndClearFramebuffer(AbstractFramebuffer* framebuffer,
const ClearColor& color_value, float depth_value)
{
SetFramebuffer(framebuffer);
+ D3D::stateman->Apply();
+
if (framebuffer->GetColorFormat() != AbstractTextureFormat::Undefined)
{
D3D::context->ClearRenderTargetView(
@@ -676,9 +302,8 @@ void Renderer::SetAndClearFramebuffer(const AbstractFramebuffer* framebuffer,
void Renderer::SetTexture(u32 index, const AbstractTexture* texture)
{
- D3D::stateman->SetTexture(
- index,
- texture ? static_cast<const DXTexture*>(texture)->GetRawTexIdentifier()->GetSRV() : nullptr);
+ D3D::stateman->SetTexture(index, texture ? static_cast<const DXTexture*>(texture)->GetD3DSRV() :
+ nullptr);
}
void Renderer::SetSamplerState(u32 index, const SamplerState& state)
@@ -686,15 +311,15 @@ void Renderer::SetSamplerState(u32 index, const SamplerState& state)
D3D::stateman->SetSampler(index, m_state_cache.Get(state));
}
-void Renderer::UnbindTexture(const AbstractTexture* texture)
+void Renderer::SetComputeImageTexture(AbstractTexture* texture, bool read, bool write)
{
- D3D::stateman->UnsetTexture(
- static_cast<const DXTexture*>(texture)->GetRawTexIdentifier()->GetSRV());
+ D3D::stateman->SetComputeUAV(texture ? static_cast<DXTexture*>(texture)->GetD3DUAV() : nullptr);
}
-void Renderer::SetInterlacingMode()
+void Renderer::UnbindTexture(const AbstractTexture* texture)
{
- // TODO
+ if (D3D::stateman->UnsetTexture(static_cast<const DXTexture*>(texture)->GetD3DSRV()) != 0)
+ D3D::stateman->ApplyTextures();
}
u16 Renderer::BBoxRead(int index)
@@ -736,93 +361,43 @@ void Renderer::BBoxWrite(int index, u16 _value)
BBox::Set(index, value);
}
+void Renderer::Flush()
+{
+ D3D::context->Flush();
+}
+
+void Renderer::WaitForGPUIdle()
+{
+ // There is no glFinish() equivalent in D3D.
+ D3D::context->Flush();
+}
+
void Renderer::RenderXFBToScreen(const AbstractTexture* texture, const EFBRectangle& rc)
{
- const CD3D11_RECT source_rc(rc.left, rc.top, rc.right, rc.bottom);
- const TargetRectangle target_rc = GetTargetRectangle();
+ if (g_ActiveConfig.stereo_mode != StereoMode::Nvidia3DVision)
+ return ::Renderer::RenderXFBToScreen(texture, rc);
- // activate linear filtering for the buffer copies
- D3D::SetLinearCopySampler();
+ if (!m_3d_vision_texture)
+ Create3DVisionTexture(m_backbuffer_width, m_backbuffer_height);
- if (g_ActiveConfig.stereo_mode == StereoMode::SBS ||
- g_ActiveConfig.stereo_mode == StereoMode::TAB)
- {
- TargetRectangle left_rc, right_rc;
- std::tie(left_rc, right_rc) = ConvertStereoRectangle(target_rc);
-
- SetViewport(static_cast<float>(left_rc.left), static_cast<float>(left_rc.top),
- static_cast<float>(left_rc.GetWidth()), static_cast<float>(right_rc.GetHeight()),
- 0.0f, 1.0f);
- D3D::drawShadedTexQuad(static_cast<const DXTexture*>(texture)->GetRawTexIdentifier()->GetSRV(),
- &source_rc, texture->GetWidth(), texture->GetHeight(),
- PixelShaderCache::GetColorCopyProgram(false),
- VertexShaderCache::GetSimpleVertexShader(),
- VertexShaderCache::GetSimpleInputLayout(), nullptr, 0);
-
- SetViewport(static_cast<float>(right_rc.left), static_cast<float>(right_rc.top),
- static_cast<float>(right_rc.GetWidth()), static_cast<float>(right_rc.GetHeight()),
- 0.0f, 1.0f);
- D3D::drawShadedTexQuad(static_cast<const DXTexture*>(texture)->GetRawTexIdentifier()->GetSRV(),
- &source_rc, texture->GetWidth(), texture->GetHeight(),
- PixelShaderCache::GetColorCopyProgram(false),
- VertexShaderCache::GetSimpleVertexShader(),
- VertexShaderCache::GetSimpleInputLayout(), nullptr, 1);
- }
- else if (g_ActiveConfig.stereo_mode == StereoMode::Nvidia3DVision)
- {
- if (!m_3d_vision_texture)
- Create3DVisionTexture(m_backbuffer_width, m_backbuffer_height);
-
- const CD3D11_VIEWPORT left_vp(
- static_cast<float>(target_rc.left), static_cast<float>(target_rc.top),
- static_cast<float>(target_rc.GetWidth()), static_cast<float>(target_rc.GetHeight()));
- const CD3D11_VIEWPORT right_vp(
- static_cast<float>(target_rc.left + m_backbuffer_width), static_cast<float>(target_rc.top),
- static_cast<float>(target_rc.GetWidth()), static_cast<float>(target_rc.GetHeight()));
-
- // Render to staging texture which is double the width of the backbuffer
- D3D::context->OMSetRenderTargets(1, &m_3d_vision_texture->GetRTV(), nullptr);
-
- D3D::context->RSSetViewports(1, &left_vp);
- D3D::drawShadedTexQuad(static_cast<const DXTexture*>(texture)->GetRawTexIdentifier()->GetSRV(),
- &source_rc, texture->GetWidth(), texture->GetHeight(),
- PixelShaderCache::GetColorCopyProgram(false),
- VertexShaderCache::GetSimpleVertexShader(),
- VertexShaderCache::GetSimpleInputLayout(), nullptr, 0);
-
- D3D::context->RSSetViewports(1, &right_vp);
- D3D::drawShadedTexQuad(static_cast<const DXTexture*>(texture)->GetRawTexIdentifier()->GetSRV(),
- &source_rc, texture->GetWidth(), texture->GetHeight(),
- PixelShaderCache::GetColorCopyProgram(false),
- VertexShaderCache::GetSimpleVertexShader(),
- VertexShaderCache::GetSimpleInputLayout(), nullptr, 1);
-
- // Copy the left eye to the backbuffer, if Nvidia 3D Vision is enabled it should
- // recognize the signature and automatically include the right eye frame.
- const CD3D11_BOX box(0, 0, 0, m_backbuffer_width, m_backbuffer_height, 1);
- D3D::context->CopySubresourceRegion(D3D::GetBackBuffer()->GetTex(), 0, 0, 0, 0,
- m_3d_vision_texture->GetTex(), 0, &box);
-
- // Restore render target to backbuffer
- D3D::context->OMSetRenderTargets(1, &D3D::GetBackBuffer()->GetRTV(), nullptr);
- }
- else
- {
- SetViewport(static_cast<float>(target_rc.left), static_cast<float>(target_rc.top),
- static_cast<float>(target_rc.GetWidth()), static_cast<float>(target_rc.GetHeight()),
- 0.0f, 1.0f);
-
- ID3D11PixelShader* pixelShader = (g_Config.stereo_mode == StereoMode::Anaglyph) ?
- PixelShaderCache::GetAnaglyphProgram() :
- PixelShaderCache::GetColorCopyProgram(false);
- ID3D11GeometryShader* geomShader = (g_ActiveConfig.stereo_mode == StereoMode::QuadBuffer) ?
- GeometryShaderCache::GetCopyGeometryShader() :
- nullptr;
- D3D::drawShadedTexQuad(static_cast<const DXTexture*>(texture)->GetRawTexIdentifier()->GetSRV(),
- &source_rc, texture->GetWidth(), texture->GetHeight(), pixelShader,
- VertexShaderCache::GetSimpleVertexShader(),
- VertexShaderCache::GetSimpleInputLayout(), geomShader);
- }
+ // Render to staging texture which is double the width of the backbuffer
+ SetAndClearFramebuffer(m_3d_vision_framebuffer.get());
+
+ const auto target_rc = GetTargetRectangle();
+ m_post_processor->BlitFromTexture(target_rc, rc, texture, 0);
+ m_post_processor->BlitFromTexture(
+ MathUtil::Rectangle<int>(target_rc.left + m_backbuffer_width, target_rc.top,
+ target_rc.right + m_backbuffer_width, target_rc.bottom),
+ rc, texture, 1);
+
+ // Copy the left eye to the backbuffer, if Nvidia 3D Vision is enabled it should
+ // recognize the signature and automatically include the right eye frame.
+ const CD3D11_BOX box(0, 0, 0, m_backbuffer_width, m_backbuffer_height, 1);
+ D3D::context->CopySubresourceRegion(D3D::GetSwapChainTexture()->GetD3DTexture(), 0, 0, 0, 0,
+ m_3d_vision_texture->GetD3DTexture(), 0, &box);
+
+ // Restore render target to backbuffer
+ SetFramebuffer(D3D::GetSwapChainFramebuffer());
}
void Renderer::SetFullscreen(bool enable_fullscreen)