Skip to content
Permalink
Browse files

Replace EFBRectangle/TargetRectangle with MathUtil::Rectangle

  • Loading branch information...
stenzek committed Apr 15, 2019
1 parent 6ea4323 commit f8c1ba409cdfc41e60d27b0fc002a8fd79f9c73e
@@ -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);
@@ -67,7 +67,8 @@ class Renderer : public ::Renderer
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:
@@ -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.
@@ -52,8 +52,8 @@ class Renderer final : public ::Renderer
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;
@@ -37,8 +37,8 @@ class Renderer : public ::Renderer
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
{
}

@@ -21,15 +21,17 @@ 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
{
}

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
{
}
@@ -932,8 +932,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 +974,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)
@@ -134,11 +134,12 @@ class Renderer : public ::Renderer

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;

@@ -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;
@@ -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();
@@ -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
@@ -25,7 +25,7 @@ class SWOGLWindow
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);

@@ -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();
@@ -42,10 +42,11 @@ class SWRenderer final : public Renderer
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 {}

@@ -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
@@ -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,
@@ -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);
}
@@ -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.
@@ -62,8 +62,8 @@ class Renderer : public ::Renderer
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;
@@ -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);
@@ -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);
}
@@ -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);

@@ -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);

0 comments on commit f8c1ba4

Please sign in to comment.
You can’t perform that action at this time.