ShuriZma
/
dolphin
mirror of https://github.com/dolphin-emu/dolphin.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Merge pull request #8000 from stenzek/more-videocommon-cleanup 

Additional cleanup/fixes from VideoCommon merge
This commit is contained in:
Connor McLaughlin 2019-04-22 12:50:22 +10:00 committed by GitHub
parent 93be178f28 356ebdf509
commit 59c0e51f5b
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
33 changed files with 163 additions and 218 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
Source/Core/VideoBackends/D3D/Render.cpp
View File

@ -327,7 +327,7 @@ void Renderer::WaitForGPUIdle()
D3D::context->Flush();
}
void Renderer::RenderXFBToScreen(const AbstractTexture* texture, const EFBRectangle& rc)
void Renderer::RenderXFBToScreen(const AbstractTexture* texture, const MathUtil::Rectangle<int>& rc)
{
if (g_ActiveConfig.stereo_mode != StereoMode::Nvidia3DVision)
return ::Renderer::RenderXFBToScreen(texture, rc);

3
Source/Core/VideoBackends/D3D/Render.h
View File

@ -67,7 +67,8 @@ public:
void Flush() override;
void WaitForGPUIdle() override;
void RenderXFBToScreen(const AbstractTexture* texture, const EFBRectangle& rc) override;
void RenderXFBToScreen(const AbstractTexture* texture,
const MathUtil::Rectangle<int>& rc) override;
void OnConfigChanged(u32 bits) override;
private:

2
Source/Core/VideoBackends/D3D12/Renderer.cpp
View File

@ -132,7 +132,7 @@ void Renderer::WaitForGPUIdle()
ExecuteCommandList(true);
}
void Renderer::ClearScreen(const EFBRectangle& rc, bool color_enable, bool alpha_enable,
void Renderer::ClearScreen(const MathUtil::Rectangle<int>& rc, bool color_enable, bool alpha_enable,
bool z_enable, u32 color, u32 z)
{
// Use a fast path without the shader if both color/alpha are enabled.

4
Source/Core/VideoBackends/D3D12/Renderer.h
View File

@ -52,8 +52,8 @@ public:
void Flush() override;
void WaitForGPUIdle() override;
void ClearScreen(const EFBRectangle& rc, bool color_enable, bool alpha_enable, bool z_enable,
u32 color, u32 z) override;
void ClearScreen(const MathUtil::Rectangle<int>& rc, bool color_enable, bool alpha_enable,
bool z_enable, u32 color, u32 z) override;
void SetPipeline(const AbstractPipeline* pipeline) override;
void SetFramebuffer(AbstractFramebuffer* framebuffer) override;

4
Source/Core/VideoBackends/Null/Render.h
View File

@ -37,8 +37,8 @@ public:
u16 BBoxRead(int index) override { return 0; }
void BBoxWrite(int index, u16 value) override {}
void ClearScreen(const EFBRectangle& rc, bool colorEnable, bool alphaEnable, bool zEnable,
u32 color, u32 z) override
void ClearScreen(const MathUtil::Rectangle<int>& rc, bool colorEnable, bool alphaEnable,
bool zEnable, u32 color, u32 z) override
{
}

14
Source/Core/VideoBackends/Null/TextureCache.h
View File

@ -21,15 +21,17 @@ public:
protected:
void CopyEFB(AbstractStagingTexture* dst, const EFBCopyParams& params, u32 native_width,
u32 bytes_per_row, u32 num_blocks_y, u32 memory_stride, const EFBRectangle& src_rect,
bool scale_by_half, bool linear_filter, float y_scale, float gamma, bool clamp_top,
bool clamp_bottom, const EFBCopyFilterCoefficients& filter_coefficients) override
u32 bytes_per_row, u32 num_blocks_y, u32 memory_stride,
const MathUtil::Rectangle<int>& src_rect, bool scale_by_half, bool linear_filter,
float y_scale, float gamma, bool clamp_top, bool clamp_bottom,
const EFBCopyFilterCoefficients& filter_coefficients) override
{
}
void CopyEFBToCacheEntry(TCacheEntry* entry, bool is_depth_copy, const EFBRectangle& src_rect,
bool scale_by_half, bool linear_filter, EFBCopyFormat dst_format,
bool is_intensity, float gamma, bool clamp_top, bool clamp_bottom,
void CopyEFBToCacheEntry(TCacheEntry* entry, bool is_depth_copy,
const MathUtil::Rectangle<int>& src_rect, bool scale_by_half,
bool linear_filter, EFBCopyFormat dst_format, bool is_intensity,
float gamma, bool clamp_top, bool clamp_bottom,
const EFBCopyFilterCoefficients& filter_coefficients) override
{
}

1
Source/Core/VideoBackends/OGL/NativeVertexFormat.cpp
View File

@ -80,6 +80,7 @@ GLVertexFormat::GLVertexFormat(const PortableVertexDeclaration& vtx_decl)
GLVertexFormat::~GLVertexFormat()
{
ProgramShaderCache::InvalidateVertexFormatIfBound(VAO);
glDeleteVertexArrays(1, &VAO);
}
} // namespace OGL

19
Source/Core/VideoBackends/OGL/OGLShader.cpp
View File

@ -24,15 +24,16 @@ static GLenum GetGLShaderTypeForStage(ShaderStage stage)
}
}
OGLShader::OGLShader(ShaderStage stage, GLenum gl_type, GLuint gl_id)
OGLShader::OGLShader(ShaderStage stage, GLenum gl_type, GLuint gl_id, std::string source)
: AbstractShader(stage), m_id(ProgramShaderCache::GenerateShaderID()), m_type(gl_type),
m_gl_id(gl_id)
m_gl_id(gl_id), m_source(std::move(source))
{
}
OGLShader::OGLShader(GLuint gl_compute_program_id)
OGLShader::OGLShader(GLuint gl_compute_program_id, std::string source)
: AbstractShader(ShaderStage::Compute), m_id(ProgramShaderCache::GenerateShaderID()),
m_type(GL_COMPUTE_SHADER), m_gl_compute_program_id(gl_compute_program_id)
m_type(GL_COMPUTE_SHADER), m_gl_compute_program_id(gl_compute_program_id),
m_source(std::move(source))
{
}
@ -47,22 +48,22 @@ OGLShader::~OGLShader()
std::unique_ptr<OGLShader> OGLShader::CreateFromSource(ShaderStage stage, const char* source,
size_t length)
{
std::string source_str(source, length);
if (stage != ShaderStage::Compute)
{
GLenum shader_type = GetGLShaderTypeForStage(stage);
GLuint shader_id =
ProgramShaderCache::CompileSingleShader(shader_type, std::string(source, length));
GLuint shader_id = ProgramShaderCache::CompileSingleShader(shader_type, source_str);
if (!shader_id)
return nullptr;
return std::make_unique<OGLShader>(stage, shader_type, shader_id);
return std::make_unique<OGLShader>(stage, shader_type, shader_id, std::move(source_str));
}
// Compute shaders.
SHADER prog;
if (!ProgramShaderCache::CompileComputeShader(prog, std::string(source, length)))
if (!ProgramShaderCache::CompileComputeShader(prog, source_str))
return nullptr;
return std::make_unique<OGLShader>(prog.glprogid);
return std::make_unique<OGLShader>(prog.glprogid, std::move(source_str));
}
} // namespace OGL

6
Source/Core/VideoBackends/OGL/OGLShader.h
View File

@ -16,14 +16,15 @@ namespace OGL
class OGLShader final : public AbstractShader
{
public:
explicit OGLShader(ShaderStage stage, GLenum gl_type, GLuint gl_id);
explicit OGLShader(GLuint gl_compute_program_id);
explicit OGLShader(ShaderStage stage, GLenum gl_type, GLuint gl_id, std::string source);
explicit OGLShader(GLuint gl_compute_program_id, std::string source);
~OGLShader() override;
u64 GetID() const { return m_id; }
GLenum GetGLShaderType() const { return m_type; }
GLuint GetGLShaderID() const { return m_gl_id; }
GLuint GetGLComputeProgramID() const { return m_gl_compute_program_id; }
const std::string& GetSource() const { return m_source; }
static std::unique_ptr<OGLShader> CreateFromSource(ShaderStage stage, const char* source,
size_t length);
@ -33,6 +34,7 @@ private:
GLenum m_type;
GLuint m_gl_id = 0;
GLuint m_gl_compute_program_id = 0;
std::string m_source;
};
} // namespace OGL

106
Source/Core/VideoBackends/OGL/ProgramShaderCache.cpp
View File

@ -267,73 +267,6 @@ void ProgramShaderCache::UploadConstants(const void* data, u32 data_size)
ADDSTAT(stats.thisFrame.bytesUniformStreamed, data_size);
}
bool ProgramShaderCache::CompileShader(SHADER& shader, const std::string& vcode,
const std::string& pcode, const std::string& gcode)
{
#if defined(_DEBUG) || defined(DEBUGFAST)
if (g_ActiveConfig.iLog & CONF_SAVESHADERS)
{
static int counter = 0;
std::string filename =
StringFromFormat("%svs_%04i.txt", File::GetUserPath(D_DUMP_IDX).c_str(), counter++);
SaveData(filename, vcode.c_str());
filename = StringFromFormat("%sps_%04i.txt", File::GetUserPath(D_DUMP_IDX).c_str(), counter++);
SaveData(filename, pcode.c_str());
if (!gcode.empty())
{
filename =
StringFromFormat("%sgs_%04i.txt", File::GetUserPath(D_DUMP_IDX).c_str(), counter++);
SaveData(filename, gcode.c_str());
}
}
#endif
shader.vsid = CompileSingleShader(GL_VERTEX_SHADER, vcode);
shader.psid = CompileSingleShader(GL_FRAGMENT_SHADER, pcode);
// Optional geometry shader
shader.gsid = 0;
if (!gcode.empty())
shader.gsid = CompileSingleShader(GL_GEOMETRY_SHADER, gcode);
if (!shader.vsid || !shader.psid || (!gcode.empty() && !shader.gsid))
{
shader.Destroy();
return false;
}
// Create and link the program.
shader.glprogid = glCreateProgram();
glAttachShader(shader.glprogid, shader.vsid);
glAttachShader(shader.glprogid, shader.psid);
if (shader.gsid)
glAttachShader(shader.glprogid, shader.gsid);
if (g_ActiveConfig.backend_info.bSupportsPipelineCacheData)
glProgramParameteri(shader.glprogid, GL_PROGRAM_BINARY_RETRIEVABLE_HINT, GL_TRUE);
shader.SetProgramBindings(false);
glLinkProgram(shader.glprogid);
if (!CheckProgramLinkResult(shader.glprogid, vcode, pcode, gcode))
{
// Don't try to use this shader
shader.Destroy();
return false;
}
// For drivers that don't support binding layout, we need to bind it here.
shader.SetProgramVariables();
// Original shaders aren't needed any more.
shader.DestroyShaders();
return true;
}
bool ProgramShaderCache::CompileComputeShader(SHADER& shader, const std::string& code)
{
// We need to enable GL_ARB_compute_shader for drivers that support the extension,
@ -358,7 +291,7 @@ bool ProgramShaderCache::CompileComputeShader(SHADER& shader, const std::string&
// original shaders aren't needed any more
glDeleteShader(shader_id);
if (!CheckProgramLinkResult(shader.glprogid, full_code, "", ""))
if (!CheckProgramLinkResult(shader.glprogid, &full_code, nullptr, nullptr))
{
shader.Destroy();
return false;
@ -441,8 +374,8 @@ bool ProgramShaderCache::CheckShaderCompileResult(GLuint id, GLenum type, const
return true;
}
bool ProgramShaderCache::CheckProgramLinkResult(GLuint id, const std::string& vcode,
const std::string& pcode, const std::string& gcode)
bool ProgramShaderCache::CheckProgramLinkResult(GLuint id, const std::string* vcode,
const std::string* pcode, const std::string* gcode)
{
GLint linkStatus;
glGetProgramiv(id, GL_LINK_STATUS, &linkStatus);
@ -460,9 +393,13 @@ bool ProgramShaderCache::CheckProgramLinkResult(GLuint id, const std::string& vc
StringFromFormat("%sbad_p_%d.txt", File::GetUserPath(D_DUMP_IDX).c_str(), num_failures++);
std::ofstream file;
File::OpenFStream(file, filename, std::ios_base::out);
file << s_glsl_header << vcode << s_glsl_header << pcode;
if (!gcode.empty())
file << s_glsl_header << gcode;
if (vcode)
file << s_glsl_header << *vcode << '\n';
if (gcode)
file << s_glsl_header << *gcode << '\n';
if (pcode)
file << s_glsl_header << *pcode << '\n';
file << info_log;
file.close();
@ -557,6 +494,12 @@ void ProgramShaderCache::InvalidateVertexFormat()
s_last_VAO = 0;
}
void ProgramShaderCache::InvalidateVertexFormatIfBound(GLuint vao)
{
if (s_last_VAO == vao)
s_last_VAO = 0;
}
void ProgramShaderCache::InvalidateLastProgram()
{
CurrentProgram = 0;
@ -640,7 +583,10 @@ PipelineProgram* ProgramShaderCache::GetPipelineProgram(const GLVertexFormat* ve
if (!s_is_shared_context && vao != s_last_VAO)
glBindVertexArray(s_last_VAO);
if (!ProgramShaderCache::CheckProgramLinkResult(prog->shader.glprogid, {}, {}, {}))
if (!ProgramShaderCache::CheckProgramLinkResult(
prog->shader.glprogid, vertex_shader ? &vertex_shader->GetSource() : nullptr,
geometry_shader ? &geometry_shader->GetSource() : nullptr,
pixel_shader ? &pixel_shader->GetSource() : nullptr))
{
prog->shader.Destroy();
return nullptr;
@ -906,6 +852,18 @@ bool SharedContextAsyncShaderCompiler::WorkerThreadInitWorkerThread(void* param)
return false;
s_is_shared_context = true;
// Make the state match the main context to have a better chance of avoiding recompiles.
if (!context->IsGLES())
glEnable(GL_PROGRAM_POINT_SIZE);
if (g_ActiveConfig.backend_info.bSupportsClipControl)
glClipControl(GL_LOWER_LEFT, GL_ZERO_TO_ONE);
if (g_ActiveConfig.backend_info.bSupportsDepthClamp)
{
glEnable(GL_CLIP_DISTANCE0);
glEnable(GL_CLIP_DISTANCE1);
glEnable(GL_DEPTH_CLAMP);
}
if (g_ActiveConfig.backend_info.bSupportsPrimitiveRestart)
GLUtil::EnablePrimitiveRestart(context);

7
Source/Core/VideoBackends/OGL/ProgramShaderCache.h
View File

@ -72,15 +72,14 @@ public:
static void BindVertexFormat(const GLVertexFormat* vertex_format);
static bool IsValidVertexFormatBound();
static void InvalidateVertexFormat();
static void InvalidateVertexFormatIfBound(GLuint vao);
static void InvalidateLastProgram();
static bool CompileShader(SHADER& shader, const std::string& vcode, const std::string& pcode,
const std::string& gcode = "");
static bool CompileComputeShader(SHADER& shader, const std::string& code);
static GLuint CompileSingleShader(GLenum type, const std::string& code);
static bool CheckShaderCompileResult(GLuint id, GLenum type, const std::string& code);
static bool CheckProgramLinkResult(GLuint id, const std::string& vcode, const std::string& pcode,
const std::string& gcode);
static bool CheckProgramLinkResult(GLuint id, const std::string* vcode, const std::string* pcode,
const std::string* gcode);
static StreamBuffer* GetUniformBuffer();
static u32 GetUniformBufferAlignment();
static void UploadConstants();

14
Source/Core/VideoBackends/OGL/Render.cpp
View File

@ -652,6 +652,10 @@ Renderer::Renderer(std::unique_ptr<GLContext> main_gl_context, float backbuffer_
// Desktop OpenGL can't have the Android Extension Pack
g_ogl_config.bSupportsAEP = false;
// Desktop GL requires GL_PROGRAM_POINT_SIZE set to use gl_PointSize in shaders.
// It is implicitly enabled in GLES.
glEnable(GL_PROGRAM_POINT_SIZE);
}
// Either method can do early-z tests. See PixelShaderGen for details.
@ -932,8 +936,8 @@ void Renderer::DispatchComputeShader(const AbstractShader* shader, u32 groups_x,
glMemoryBarrier(GL_TEXTURE_UPDATE_BARRIER_BIT);
}
void Renderer::ClearScreen(const EFBRectangle& rc, bool colorEnable, bool alphaEnable, bool zEnable,
u32 color, u32 z)
void Renderer::ClearScreen(const MathUtil::Rectangle<int>& rc, bool colorEnable, bool alphaEnable,
bool zEnable, u32 color, u32 z)
{
g_framebuffer_manager->FlushEFBPokes();
g_framebuffer_manager->FlagPeekCacheAsOutOfDate();
@ -974,7 +978,7 @@ void Renderer::ClearScreen(const EFBRectangle& rc, bool colorEnable, bool alphaE
BPFunctions::SetScissor();
}
void Renderer::RenderXFBToScreen(const AbstractTexture* texture, const EFBRectangle& rc)
void Renderer::RenderXFBToScreen(const AbstractTexture* texture, const MathUtil::Rectangle<int>& rc)
{
// Quad-buffered stereo is annoying on GL.
if (g_ActiveConfig.stereo_mode != StereoMode::QuadBuffer)
@ -1108,8 +1112,6 @@ void Renderer::CheckForSurfaceResize()
void Renderer::BeginUtilityDrawing()
{
::Renderer::BeginUtilityDrawing();
glEnable(GL_PROGRAM_POINT_SIZE);
if (g_ActiveConfig.backend_info.bSupportsDepthClamp)
{
glDisable(GL_CLIP_DISTANCE0);
@ -1120,8 +1122,6 @@ void Renderer::BeginUtilityDrawing()
void Renderer::EndUtilityDrawing()
{
::Renderer::EndUtilityDrawing();
glDisable(GL_PROGRAM_POINT_SIZE);
if (g_ActiveConfig.backend_info.bSupportsDepthClamp)
{
glEnable(GL_CLIP_DISTANCE0);

7
Source/Core/VideoBackends/OGL/Render.h
View File

@ -134,11 +134,12 @@ public:
void Flush() override;
void WaitForGPUIdle() override;
void RenderXFBToScreen(const AbstractTexture* texture, const EFBRectangle& rc) override;
void RenderXFBToScreen(const AbstractTexture* texture,
const MathUtil::Rectangle<int>& rc) override;
void OnConfigChanged(u32 bits) override;
void ClearScreen(const EFBRectangle& rc, bool colorEnable, bool alphaEnable, bool zEnable,
u32 color, u32 z) override;
void ClearScreen(const MathUtil::Rectangle<int>& rc, bool colorEnable, bool alphaEnable,
bool zEnable, u32 color, u32 z) override;
std::unique_ptr<VideoCommon::AsyncShaderCompiler> CreateAsyncShaderCompiler() override;

9
Source/Core/VideoBackends/Software/EfbInterface.cpp
View File

@ -549,8 +549,8 @@ u8* GetPixelPointer(u16 x, u16 y, bool depth)
return &efb[GetColorOffset(x, y)];
}
void EncodeXFB(u8* xfb_in_ram, u32 memory_stride, const EFBRectangle& source_rect, float y_scale,
float gamma)
void EncodeXFB(u8* xfb_in_ram, u32 memory_stride, const MathUtil::Rectangle<int>& source_rect,
float y_scale, float gamma)
{
if (!xfb_in_ram)
{
@ -628,8 +628,9 @@ void EncodeXFB(u8* xfb_in_ram, u32 memory_stride, const EFBRectangle& source_rec
src_ptr += memory_stride;
}
auto dest_rect = EFBRectangle{source_rect.left, source_rect.top, source_rect.right,
static_cast<int>(static_cast<float>(source_rect.bottom) * y_scale)};
auto dest_rect =
MathUtil::Rectangle<int>{source_rect.left, source_rect.top, source_rect.right,
static_cast<int>(static_cast<float>(source_rect.bottom) * y_scale)};
const std::size_t destination_size = dest_rect.GetWidth() * dest_rect.GetHeight() * 2;
static std::vector<yuv422_packed> destination;

4
Source/Core/VideoBackends/Software/EfbInterface.h
View File

@ -54,8 +54,8 @@ u32 GetDepth(u16 x, u16 y);
u8* GetPixelPointer(u16 x, u16 y, bool depth);
void EncodeXFB(u8* xfb_in_ram, u32 memory_stride, const EFBRectangle& source_rect, float y_scale,
float gamma);
void EncodeXFB(u8* xfb_in_ram, u32 memory_stride, const MathUtil::Rectangle<int>& source_rect,
float y_scale, float gamma);
u32 GetPerfQueryResult(PerfQueryType type);
void ResetPerfQuery();

3
Source/Core/VideoBackends/Software/SWOGLWindow.cpp
View File

@ -84,7 +84,8 @@ bool SWOGLWindow::Initialize(const WindowSystemInfo& wsi)
return true;
}
void SWOGLWindow::ShowImage(const AbstractTexture* image, const EFBRectangle& xfb_region)
void SWOGLWindow::ShowImage(const AbstractTexture* image,
const MathUtil::Rectangle<int>& xfb_region)
{
const SW::SWTexture* sw_image = static_cast<const SW::SWTexture*>(image);
m_gl_context->Update(); // just updates the render window position and the backbuffer size

2
Source/Core/VideoBackends/Software/SWOGLWindow.h
View File

@ -25,7 +25,7 @@ public:
bool IsHeadless() const;
// Image to show, will be swapped immediately
void ShowImage(const AbstractTexture* image, const EFBRectangle& xfb_region);
void ShowImage(const AbstractTexture* image, const MathUtil::Rectangle<int>& xfb_region);
static std::unique_ptr<SWOGLWindow> Create(const WindowSystemInfo& wsi);

5
Source/Core/VideoBackends/Software/SWRenderer.cpp
View File

@ -94,7 +94,8 @@ std::unique_ptr<AbstractPipeline> SWRenderer::CreatePipeline(const AbstractPipel
}
// Called on the GPU thread
void SWRenderer::RenderXFBToScreen(const AbstractTexture* texture, const EFBRectangle& xfb_region)
void SWRenderer::RenderXFBToScreen(const AbstractTexture* texture,
const MathUtil::Rectangle<int>& xfb_region)
{
if (!IsHeadless())
m_window->ShowImage(texture, xfb_region);
@ -136,7 +137,7 @@ void SWRenderer::BBoxWrite(int index, u16 value)
BoundingBox::coords[index] = value;
}
void SWRenderer::ClearScreen(const EFBRectangle& rc, bool colorEnable, bool alphaEnable,
void SWRenderer::ClearScreen(const MathUtil::Rectangle<int>& rc, bool colorEnable, bool alphaEnable,
bool zEnable, u32 color, u32 z)
{
EfbCopy::ClearEfb();

7
Source/Core/VideoBackends/Software/SWRenderer.h
View File

@ -42,10 +42,11 @@ public:
u16 BBoxRead(int index) override;
void BBoxWrite(int index, u16 value) override;
void RenderXFBToScreen(const AbstractTexture* texture, const EFBRectangle& rc) override;
void RenderXFBToScreen(const AbstractTexture* texture,
const MathUtil::Rectangle<int>& rc) override;
void ClearScreen(const EFBRectangle& rc, bool colorEnable, bool alphaEnable, bool zEnable,
u32 color, u32 z) override;
void ClearScreen(const MathUtil::Rectangle<int>& rc, bool colorEnable, bool alphaEnable,
bool zEnable, u32 color, u32 z) override;
void ReinterpretPixelData(EFBReinterpretType convtype) override {}

14
Source/Core/VideoBackends/Software/TextureCache.h
View File

@ -11,16 +11,18 @@ class TextureCache : public TextureCacheBase
{
protected:
void CopyEFB(AbstractStagingTexture* dst, const EFBCopyParams& params, u32 native_width,
u32 bytes_per_row, u32 num_blocks_y, u32 memory_stride, const EFBRectangle& src_rect,
bool scale_by_half, bool linear_filter, float y_scale, float gamma, bool clamp_top,
bool clamp_bottom, const EFBCopyFilterCoefficients& filter_coefficients) override
u32 bytes_per_row, u32 num_blocks_y, u32 memory_stride,
const MathUtil::Rectangle<int>& src_rect, bool scale_by_half, bool linear_filter,
float y_scale, float gamma, bool clamp_top, bool clamp_bottom,
const EFBCopyFilterCoefficients& filter_coefficients) override
{
TextureEncoder::Encode(dst, params, native_width, bytes_per_row, num_blocks_y, memory_stride,
src_rect, scale_by_half, y_scale, gamma);
}
void CopyEFBToCacheEntry(TCacheEntry* entry, bool is_depth_copy, const EFBRectangle& src_rect,
bool scale_by_half, bool linear_filter, EFBCopyFormat dst_format,
bool is_intensity, float gamma, bool clamp_top, bool clamp_bottom,
void CopyEFBToCacheEntry(TCacheEntry* entry, bool is_depth_copy,
const MathUtil::Rectangle<int>& src_rect, bool scale_by_half,
bool linear_filter, EFBCopyFormat dst_format, bool is_intensity,
float gamma, bool clamp_top, bool clamp_bottom,
const EFBCopyFilterCoefficients& filter_coefficients) override
{
// TODO: If we ever want to "fake" vram textures, we would need to implement this

7
Source/Core/VideoBackends/Software/TextureEncoder.cpp
View File

@ -1422,7 +1422,7 @@ static void EncodeZ24halfscale(u8* dst, const u8* src, EFBCopyFormat format)
namespace
{
void EncodeEfbCopy(u8* dst, const EFBCopyParams& params, u32 native_width, u32 bytes_per_row,
u32 num_blocks_y, u32 memory_stride, const EFBRectangle& src_rect,
u32 num_blocks_y, u32 memory_stride, const MathUtil::Rectangle<int>& src_rect,
bool scale_by_half)
{
const u8* src = EfbInterface::GetPixelPointer(src_rect.left, src_rect.top, params.depth);
@ -1471,8 +1471,9 @@ void EncodeEfbCopy(u8* dst, const EFBCopyParams& params, u32 native_width, u32 b
}
void Encode(AbstractStagingTexture* dst, const EFBCopyParams& params, u32 native_width,
u32 bytes_per_row, u32 num_blocks_y, u32 memory_stride, const EFBRectangle& src_rect,
bool scale_by_half, float y_scale, float gamma)
u32 bytes_per_row, u32 num_blocks_y, u32 memory_stride,
const MathUtil::Rectangle<int>& src_rect, bool scale_by_half, float y_scale,
float gamma)
{
// HACK: Override the memory stride for this staging texture with new copy stride.
// This is required because the texture encoder assumes that we're writing directly to memory,

5
Source/Core/VideoBackends/Software/TextureEncoder.h
View File

@ -11,6 +11,7 @@
namespace TextureEncoder
{
void Encode(AbstractStagingTexture* dst, const EFBCopyParams& params, u32 native_width,
u32 bytes_per_row, u32 num_blocks_y, u32 memory_stride, const EFBRectangle& src_rect,
bool scale_by_half, float y_scale, float gamma);
u32 bytes_per_row, u32 num_blocks_y, u32 memory_stride,
const MathUtil::Rectangle<int>& src_rect, bool scale_by_half, float y_scale,
float gamma);
}

4
Source/Core/VideoBackends/Vulkan/Renderer.cpp
View File

@ -147,14 +147,14 @@ void Renderer::BBoxFlush()
m_bounding_box->Invalidate();
}
void Renderer::ClearScreen(const EFBRectangle& rc, bool color_enable, bool alpha_enable,
void Renderer::ClearScreen(const MathUtil::Rectangle<int>& rc, bool color_enable, bool alpha_enable,
bool z_enable, u32 color, u32 z)
{
g_framebuffer_manager->FlushEFBPokes();
g_framebuffer_manager->FlagPeekCacheAsOutOfDate();
// Native -> EFB coordinates
TargetRectangle target_rc = Renderer::ConvertEFBRectangle(rc);
MathUtil::Rectangle<int> target_rc = Renderer::ConvertEFBRectangle(rc);
// Size we pass this size to vkBeginRenderPass, it has to be clamped to the framebuffer
// dimensions. The other backends just silently ignore this case.

4
Source/Core/VideoBackends/Vulkan/Renderer.h
View File

@ -62,8 +62,8 @@ public:
void WaitForGPUIdle() override;
void OnConfigChanged(u32 bits) override;
void ClearScreen(const EFBRectangle& rc, bool color_enable, bool alpha_enable, bool z_enable,
u32 color, u32 z) override;
void ClearScreen(const MathUtil::Rectangle<int>& rc, bool color_enable, bool alpha_enable,
bool z_enable, u32 color, u32 z) override;
void SetPipeline(const AbstractPipeline* pipeline) override;
void SetFramebuffer(AbstractFramebuffer* framebuffer) override;

6
Source/Core/VideoCommon/BPFunctions.cpp
View File

@ -49,8 +49,8 @@ void SetScissor()
const int xoff = bpmem.scissorOffset.x * 2;
const int yoff = bpmem.scissorOffset.y * 2;
EFBRectangle native_rc(bpmem.scissorTL.x - xoff, bpmem.scissorTL.y - yoff,
bpmem.scissorBR.x - xoff + 1, bpmem.scissorBR.y - yoff + 1);
MathUtil::Rectangle<int> native_rc(bpmem.scissorTL.x - xoff, bpmem.scissorTL.y - yoff,
bpmem.scissorBR.x - xoff + 1, bpmem.scissorBR.y - yoff + 1);
native_rc.ClampUL(0, 0, EFB_WIDTH, EFB_HEIGHT);
auto target_rc = g_renderer->ConvertEFBRectangle(native_rc);
@ -172,7 +172,7 @@ void SetBlendMode()
- convert the RGBA8 color to RGBA6/RGB8/RGB565 and convert it to RGBA8 again
- convert the Z24 depth value to Z16 and back to Z24
*/
void ClearScreen(const EFBRectangle& rc)
void ClearScreen(const MathUtil::Rectangle<int>& rc)
{
bool colorEnable = (bpmem.blendmode.colorupdate != 0);
bool alphaEnable = (bpmem.blendmode.alphaupdate != 0);

2
Source/Core/VideoCommon/BPFunctions.h
View File

@ -20,7 +20,7 @@ void SetScissor();
void SetViewport();
void SetDepthMode();
void SetBlendMode();
void ClearScreen(const EFBRectangle& rc);
void ClearScreen(const MathUtil::Rectangle<int>& rc);
void OnPixelFormatChange();
void SetInterlacingMode(const BPCmd& bp);
}

2
Source/Core/VideoCommon/BPStructs.cpp
View File

@ -219,7 +219,7 @@ static void BPWritten(const BPCmd& bp)
u32 destAddr = bpmem.copyTexDest << 5;
u32 destStride = bpmem.copyMipMapStrideChannels << 5;
EFBRectangle srcRect;
MathUtil::Rectangle<int> srcRect;
srcRect.left = static_cast<int>(bpmem.copyTexSrcXY.x);
srcRect.top = static_cast<int>(bpmem.copyTexSrcXY.y);

26
Source/Core/VideoCommon/RenderBase.cpp
View File

@ -158,8 +158,8 @@ bool Renderer::EFBHasAlphaChannel() const
return m_prev_efb_format == PEControl::RGBA6_Z24;
}
void Renderer::ClearScreen(const EFBRectangle& rc, bool colorEnable, bool alphaEnable, bool zEnable,
u32 color, u32 z)
void Renderer::ClearScreen(const MathUtil::Rectangle<int>& rc, bool colorEnable, bool alphaEnable,
bool zEnable, u32 color, u32 z)
{
g_framebuffer_manager->ClearEFB(rc, colorEnable, alphaEnable, zEnable, color, z);
}
@ -258,8 +258,8 @@ void Renderer::PokeEFB(EFBAccessType type, const EfbPokeData* points, size_t num
}
}
void Renderer::RenderToXFB(u32 xfbAddr, const EFBRectangle& sourceRc, u32 fbStride, u32 fbHeight,
float Gamma)
void Renderer::RenderToXFB(u32 xfbAddr, const MathUtil::Rectangle<int>& sourceRc, u32 fbStride,
u32 fbHeight, float Gamma)
{
CheckFifoRecording();
@ -332,11 +332,11 @@ bool Renderer::CalculateTargetSize()
return false;
}
std::tuple<TargetRectangle, TargetRectangle>
Renderer::ConvertStereoRectangle(const TargetRectangle& rc) const
std::tuple<MathUtil::Rectangle<int>, MathUtil::Rectangle<int>>
Renderer::ConvertStereoRectangle(const MathUtil::Rectangle<int>& rc) const
{
// Resize target to half its original size
TargetRectangle draw_rc = rc;
auto draw_rc = rc;
if (g_ActiveConfig.stereo_mode == StereoMode::TAB)
{
// The height may be negative due to flipped rectangles
@ -352,8 +352,8 @@ Renderer::ConvertStereoRectangle(const TargetRectangle& rc) const
}
// Create two target rectangle offset to the sides of the backbuffer
TargetRectangle left_rc = draw_rc;
TargetRectangle right_rc = draw_rc;
auto left_rc = draw_rc;
auto right_rc = draw_rc;
if (g_ActiveConfig.stereo_mode == StereoMode::TAB)
{
left_rc.top -= m_backbuffer_height / 4;
@ -649,9 +649,9 @@ MathUtil::Rectangle<int> Renderer::ConvertFramebufferRectangle(const MathUtil::R
return ret;
}
TargetRectangle Renderer::ConvertEFBRectangle(const EFBRectangle& rc)
MathUtil::Rectangle<int> Renderer::ConvertEFBRectangle(const MathUtil::Rectangle<int>& rc)
{
TargetRectangle result;
MathUtil::Rectangle<int> result;
result.left = EFBToScaledX(rc.left);
result.top = EFBToScaledY(rc.top);
result.right = EFBToScaledX(rc.right);
@ -1285,13 +1285,13 @@ void Renderer::Swap(u32 xfb_addr, u32 fb_width, u32 fb_stride, u32 fb_height, u6
}
}
void Renderer::RenderXFBToScreen(const AbstractTexture* texture, const EFBRectangle& rc)
void Renderer::RenderXFBToScreen(const AbstractTexture* texture, const MathUtil::Rectangle<int>& rc)
{
const auto target_rc = GetTargetRectangle();
if (g_ActiveConfig.stereo_mode == StereoMode::SBS ||
g_ActiveConfig.stereo_mode == StereoMode::TAB)
{
TargetRectangle left_rc, right_rc;
MathUtil::Rectangle<int> left_rc, right_rc;
std::tie(left_rc, right_rc) = ConvertStereoRectangle(target_rc);
m_post_processor->BlitFromTexture(left_rc, rc, texture, 0);

21
Source/Core/VideoCommon/RenderBase.h
View File

@ -166,17 +166,17 @@ public:
// EFB coordinate conversion functions
// Use this to convert a whole native EFB rect to backbuffer coordinates
TargetRectangle ConvertEFBRectangle(const EFBRectangle& rc);
MathUtil::Rectangle<int> ConvertEFBRectangle(const MathUtil::Rectangle<int>& rc);
const TargetRectangle& GetTargetRectangle() const { return m_target_rectangle; }
const MathUtil::Rectangle<int>& GetTargetRectangle() const { return m_target_rectangle; }
float CalculateDrawAspectRatio() const;
std::tuple<float, float> ScaleToDisplayAspectRatio(int width, int height) const;
void UpdateDrawRectangle();
// Use this to convert a single target rectangle to two stereo rectangles
std::tuple<TargetRectangle, TargetRectangle>
ConvertStereoRectangle(const TargetRectangle& rc) const;
std::tuple<MathUtil::Rectangle<int>, MathUtil::Rectangle<int>>
ConvertStereoRectangle(const MathUtil::Rectangle<int>& rc) const;
unsigned int GetEFBScale() const;
@ -195,11 +195,11 @@ public:
// ImGui initialization depends on being able to create textures and pipelines, so do it last.
bool InitializeImGui();
virtual void ClearScreen(const EFBRectangle& rc, bool colorEnable, bool alphaEnable, bool zEnable,
u32 color, u32 z);
virtual void ClearScreen(const MathUtil::Rectangle<int>& rc, bool colorEnable, bool alphaEnable,
bool zEnable, u32 color, u32 z);
virtual void ReinterpretPixelData(EFBReinterpretType convtype);
void RenderToXFB(u32 xfbAddr, const EFBRectangle& sourceRc, u32 fbStride, u32 fbHeight,
float Gamma = 1.0f);
void RenderToXFB(u32 xfbAddr, const MathUtil::Rectangle<int>& sourceRc, u32 fbStride,
u32 fbHeight, float Gamma = 1.0f);
virtual u32 AccessEFB(EFBAccessType type, u32 x, u32 y, u32 poke_data);
virtual void PokeEFB(EFBAccessType type, const EfbPokeData* points, size_t num_points);
@ -216,7 +216,8 @@ public:
// Draws the specified XFB buffer to the screen, performing any post-processing.
// Assumes that the backbuffer has already been bound and cleared.
virtual void RenderXFBToScreen(const AbstractTexture* texture, const EFBRectangle& rc);
virtual void RenderXFBToScreen(const AbstractTexture* texture,
const MathUtil::Rectangle<int>& rc);
// Called when the configuration changes, and backend structures need to be updated.
virtual void OnConfigChanged(u32 bits) {}
@ -294,7 +295,7 @@ protected:
int m_backbuffer_height = 0;
float m_backbuffer_scale = 1.0f;
AbstractTextureFormat m_backbuffer_format = AbstractTextureFormat::Undefined;
TargetRectangle m_target_rectangle = {};
MathUtil::Rectangle<int> m_target_rectangle = {};
int m_frame_count = 0;
FPSCounter m_fps_counter;

4
Source/Core/VideoCommon/ShaderCache.cpp
View File

@ -94,7 +94,9 @@ void ShaderCache::Shutdown()
{
// This may leave shaders uncommitted to the cache, but it's better than blocking shutdown
// until everything has finished compiling.
m_async_shader_compiler->StopWorkerThreads();
if (m_async_shader_compiler)
m_async_shader_compiler->StopWorkerThreads();
ClosePipelineUIDCache();
}

19
Source/Core/VideoCommon/TextureCacheBase.cpp
View File

@ -1527,8 +1527,9 @@ bool TextureCacheBase::NeedsCopyFilterInShader(const EFBCopyFilterCoefficients&
void TextureCacheBase::CopyRenderTargetToTexture(
u32 dstAddr, EFBCopyFormat dstFormat, u32 width, u32 height, u32 dstStride, bool is_depth_copy,
const EFBRectangle& srcRect, bool isIntensity, bool scaleByHalf, float y_scale, float gamma,
bool clamp_top, bool clamp_bottom, const CopyFilterCoefficients::Values& filter_coefficients)
const MathUtil::Rectangle<int>& srcRect, bool isIntensity, bool scaleByHalf, float y_scale,
float gamma, bool clamp_top, bool clamp_bottom,
const CopyFilterCoefficients::Values& filter_coefficients)
{
// Emulation methods:
//
@ -2158,10 +2159,10 @@ bool TextureCacheBase::CreateUtilityTextures()
}
void TextureCacheBase::CopyEFBToCacheEntry(TCacheEntry* entry, bool is_depth_copy,
const EFBRectangle& src_rect, bool scale_by_half,
bool linear_filter, EFBCopyFormat dst_format,
bool is_intensity, float gamma, bool clamp_top,
bool clamp_bottom,
const MathUtil::Rectangle<int>& src_rect,
bool scale_by_half, bool linear_filter,
EFBCopyFormat dst_format, bool is_intensity, float gamma,
bool clamp_top, bool clamp_bottom,
const EFBCopyFilterCoefficients& filter_coefficients)
{
// Flush EFB pokes first, as they're expected to be included.
@ -2229,9 +2230,9 @@ void TextureCacheBase::CopyEFBToCacheEntry(TCacheEntry* entry, bool is_depth_cop
void TextureCacheBase::CopyEFB(AbstractStagingTexture* dst, const EFBCopyParams& params,
u32 native_width, u32 bytes_per_row, u32 num_blocks_y,
u32 memory_stride, const EFBRectangle& src_rect, bool scale_by_half,
bool linear_filter, float y_scale, float gamma, bool clamp_top,
bool clamp_bottom,
u32 memory_stride, const MathUtil::Rectangle<int>& src_rect,
bool scale_by_half, bool linear_filter, float y_scale, float gamma,
bool clamp_top, bool clamp_bottom,
const EFBCopyFilterCoefficients& filter_coefficients)
{
// Flush EFB pokes first, as they're expected to be included.

15
Source/Core/VideoCommon/TextureCacheBase.h
View File

@ -213,9 +213,10 @@ public:
virtual void BindTextures();
void CopyRenderTargetToTexture(u32 dstAddr, EFBCopyFormat dstFormat, u32 width, u32 height,
u32 dstStride, bool is_depth_copy, const EFBRectangle& srcRect,
bool isIntensity, bool scaleByHalf, float y_scale, float gamma,
bool clamp_top, bool clamp_bottom,
u32 dstStride, bool is_depth_copy,
const MathUtil::Rectangle<int>& srcRect, bool isIntensity,
bool scaleByHalf, float y_scale, float gamma, bool clamp_top,
bool clamp_bottom,
const CopyFilterCoefficients::Values& filter_coefficients);
void ScaleTextureCacheEntryTo(TCacheEntry* entry, u32 new_width, u32 new_height);
@ -243,11 +244,11 @@ protected:
virtual void CopyEFB(AbstractStagingTexture* dst, const EFBCopyParams& params, u32 native_width,
u32 bytes_per_row, u32 num_blocks_y, u32 memory_stride,
const EFBRectangle& src_rect, bool scale_by_half, bool linear_filter,
float y_scale, float gamma, bool clamp_top, bool clamp_bottom,
const EFBCopyFilterCoefficients& filter_coefficients);
const MathUtil::Rectangle<int>& src_rect, bool scale_by_half,
bool linear_filter, float y_scale, float gamma, bool clamp_top,
bool clamp_bottom, const EFBCopyFilterCoefficients& filter_coefficients);
virtual void CopyEFBToCacheEntry(TCacheEntry* entry, bool is_depth_copy,
const EFBRectangle& src_rect, bool scale_by_half,
const MathUtil::Rectangle<int>& src_rect, bool scale_by_half,
bool linear_filter, EFBCopyFormat dst_format, bool is_intensity,
float gamma, bool clamp_top, bool clamp_bottom,
const EFBCopyFilterCoefficients& filter_coefficients);

33
Source/Core/VideoCommon/VideoCommon.h
View File

@ -3,11 +3,6 @@
// Refer to the license.txt file included.
#pragma once
#ifdef _WIN32
#include <windows.h>
#endif
#include "Common/CommonTypes.h"
#include "Common/MathUtil.h"
@ -31,34 +26,6 @@ const u32 MAX_XFB_WIDTH = 720;
// that are next to each other in memory (TODO: handle that situation).
const u32 MAX_XFB_HEIGHT = 576;
// This structure should only be used to represent a rectangle in EFB
// coordinates, where the origin is at the upper left and the frame dimensions
// are 640 x 528.
typedef MathUtil::Rectangle<int> EFBRectangle;
// This structure should only be used to represent a rectangle in standard target
// coordinates, where the origin is at the lower left and the frame dimensions
// depend on the resolution settings. Use Renderer::ConvertEFBRectangle to
// convert an EFBRectangle to a TargetRectangle.
struct TargetRectangle : public MathUtil::Rectangle<int>
{
#ifdef _WIN32
// Only used by D3D backend.
const RECT* AsRECT() const
{
// The types are binary compatible so this works.
return (const RECT*)this;
}
RECT* AsRECT()
{
// The types are binary compatible so this works.
return (RECT*)this;
}
#endif
TargetRectangle(const MathUtil::Rectangle<int>& other) : MathUtil::Rectangle<int>(other) {}
TargetRectangle() = default;
};
#ifdef _WIN32
#define PRIM_LOG(...) DEBUG_LOG(VIDEO, __VA_ARGS__)
#else