From 3fe77be392798408823ab80e84db265351fc14ab Mon Sep 17 00:00:00 2001 From: Subv Date: Mon, 20 Aug 2018 15:18:51 -0500 Subject: [PATCH 1/2] Rasterizer: Don't attempt to copy over the old texture's data when doing a format reinterpretation if we're only going to clear the framebuffer. --- .../renderer_opengl/gl_rasterizer.cpp | 9 +++++---- src/video_core/renderer_opengl/gl_rasterizer.h | 3 ++- .../renderer_opengl/gl_rasterizer_cache.cpp | 17 +++++++++++------ .../renderer_opengl/gl_rasterizer_cache.h | 5 +++-- 4 files changed, 21 insertions(+), 13 deletions(-) diff --git a/src/video_core/renderer_opengl/gl_rasterizer.cpp b/src/video_core/renderer_opengl/gl_rasterizer.cpp index fe1f55e850..73c59e5cc5 100644 --- a/src/video_core/renderer_opengl/gl_rasterizer.cpp +++ b/src/video_core/renderer_opengl/gl_rasterizer.cpp @@ -304,7 +304,8 @@ bool RasterizerOpenGL::AccelerateDrawBatch(bool is_indexed) { } std::pair RasterizerOpenGL::ConfigureFramebuffers(bool using_color_fb, - bool using_depth_fb) { + bool using_depth_fb, + bool preserve_contents) { const auto& regs = Core::System::GetInstance().GPU().Maxwell3D().regs; if (regs.rt[0].format == Tegra::RenderTargetFormat::NONE) { @@ -327,7 +328,7 @@ std::pair RasterizerOpenGL::ConfigureFramebuffers(bool using_c Surface depth_surface; MathUtil::Rectangle surfaces_rect; std::tie(color_surface, depth_surface, surfaces_rect) = - res_cache.GetFramebufferSurfaces(using_color_fb, using_depth_fb); + res_cache.GetFramebufferSurfaces(using_color_fb, using_depth_fb, preserve_contents); const MathUtil::Rectangle viewport_rect{regs.viewport_transform[0].GetRect()}; const MathUtil::Rectangle draw_rect{ @@ -390,7 +391,7 @@ void RasterizerOpenGL::Clear() { ScopeAcquireGLContext acquire_context{emu_window}; auto [dirty_color_surface, dirty_depth_surface] = - ConfigureFramebuffers(use_color_fb, use_depth_fb); + ConfigureFramebuffers(use_color_fb, use_depth_fb, false); // TODO(Subv): Support clearing only partial colors. glClearColor(regs.clear_color[0], regs.clear_color[1], regs.clear_color[2], @@ -445,7 +446,7 @@ void RasterizerOpenGL::DrawArrays() { ScopeAcquireGLContext acquire_context{emu_window}; auto [dirty_color_surface, dirty_depth_surface] = - ConfigureFramebuffers(true, regs.zeta.Address() != 0 && regs.zeta_enable != 0); + ConfigureFramebuffers(true, regs.zeta.Address() != 0 && regs.zeta_enable != 0, true); SyncDepthTestState(); SyncBlendState(); diff --git a/src/video_core/renderer_opengl/gl_rasterizer.h b/src/video_core/renderer_opengl/gl_rasterizer.h index 74307f6265..4a7c5b9235 100644 --- a/src/video_core/renderer_opengl/gl_rasterizer.h +++ b/src/video_core/renderer_opengl/gl_rasterizer.h @@ -87,7 +87,8 @@ private: /// Configures the color and depth framebuffer states and returns the dirty /// surfaces if writing was enabled. - std::pair ConfigureFramebuffers(bool using_color_fb, bool using_depth_fb); + std::pair ConfigureFramebuffers(bool using_color_fb, bool using_depth_fb, + bool preserve_contents); /// Binds the framebuffer color and depth surface void BindFramebufferSurfaces(const Surface& color_surface, const Surface& depth_surface, diff --git a/src/video_core/renderer_opengl/gl_rasterizer_cache.cpp b/src/video_core/renderer_opengl/gl_rasterizer_cache.cpp index fb7476fb89..27bf9ece7c 100644 --- a/src/video_core/renderer_opengl/gl_rasterizer_cache.cpp +++ b/src/video_core/renderer_opengl/gl_rasterizer_cache.cpp @@ -686,7 +686,8 @@ Surface RasterizerCacheOpenGL::GetTextureSurface(const Tegra::Texture::FullTextu } SurfaceSurfaceRect_Tuple RasterizerCacheOpenGL::GetFramebufferSurfaces(bool using_color_fb, - bool using_depth_fb) { + bool using_depth_fb, + bool preserve_contents) { const auto& regs = Core::System::GetInstance().GPU().Maxwell3D().regs; // TODO(bunnei): This is hard corded to use just the first render buffer @@ -708,7 +709,7 @@ SurfaceSurfaceRect_Tuple RasterizerCacheOpenGL::GetFramebufferSurfaces(bool usin MathUtil::Rectangle color_rect{}; Surface color_surface; if (using_color_fb) { - color_surface = GetSurface(color_params); + color_surface = GetSurface(color_params, preserve_contents); if (color_surface) { color_rect = color_surface->GetSurfaceParams().GetRect(); } @@ -717,7 +718,7 @@ SurfaceSurfaceRect_Tuple RasterizerCacheOpenGL::GetFramebufferSurfaces(bool usin MathUtil::Rectangle depth_rect{}; Surface depth_surface; if (using_depth_fb) { - depth_surface = GetSurface(depth_params); + depth_surface = GetSurface(depth_params, preserve_contents); if (depth_surface) { depth_rect = depth_surface->GetSurfaceParams().GetRect(); } @@ -752,7 +753,7 @@ void RasterizerCacheOpenGL::FlushSurface(const Surface& surface) { surface->FlushGLBuffer(); } -Surface RasterizerCacheOpenGL::GetSurface(const SurfaceParams& params) { +Surface RasterizerCacheOpenGL::GetSurface(const SurfaceParams& params, bool preserve_contents) { if (params.addr == 0 || params.height * params.width == 0) { return {}; } @@ -774,9 +775,13 @@ Surface RasterizerCacheOpenGL::GetSurface(const SurfaceParams& params) { } else if (surface->GetSurfaceParams().IsCompatibleSurface(params)) { // Use the cached surface as-is return surface; - } else { - // If surface parameters changed, recreate the surface from the old one + } else if (preserve_contents) { + // If surface parameters changed and we care about keeping the previous data, recreate + // the surface from the old one return RecreateSurface(surface, params); + } else { + // Delete the old surface before creating a new one to prevent collisions. + UnregisterSurface(surface); } } diff --git a/src/video_core/renderer_opengl/gl_rasterizer_cache.h b/src/video_core/renderer_opengl/gl_rasterizer_cache.h index fc8b442193..907e7d6066 100644 --- a/src/video_core/renderer_opengl/gl_rasterizer_cache.h +++ b/src/video_core/renderer_opengl/gl_rasterizer_cache.h @@ -722,7 +722,8 @@ public: Surface GetTextureSurface(const Tegra::Texture::FullTextureInfo& config); /// Get the color and depth surfaces based on the framebuffer configuration - SurfaceSurfaceRect_Tuple GetFramebufferSurfaces(bool using_color_fb, bool using_depth_fb); + SurfaceSurfaceRect_Tuple GetFramebufferSurfaces(bool using_color_fb, bool using_depth_fb, + bool preserve_contents); /// Flushes the surface to Switch memory void FlushSurface(const Surface& surface); @@ -738,7 +739,7 @@ public: private: void LoadSurface(const Surface& surface); - Surface GetSurface(const SurfaceParams& params); + Surface GetSurface(const SurfaceParams& params, bool preserve_contents = true); /// Recreates a surface with new parameters Surface RecreateSurface(const Surface& surface, const SurfaceParams& new_params); From d7c68fbb120c8881b874b4c65efa9ad63a332304 Mon Sep 17 00:00:00 2001 From: Subv Date: Mon, 20 Aug 2018 15:19:59 -0500 Subject: [PATCH 2/2] Rasterizer: Reinterpret the raw texture bytes instead of blitting (and thus doing format conversion) to a new texture when a game requests an old texture address with a different format. --- .../renderer_opengl/gl_rasterizer_cache.cpp | 52 +++++++++++++++++-- 1 file changed, 49 insertions(+), 3 deletions(-) diff --git a/src/video_core/renderer_opengl/gl_rasterizer_cache.cpp b/src/video_core/renderer_opengl/gl_rasterizer_cache.cpp index 27bf9ece7c..817fa07a8d 100644 --- a/src/video_core/renderer_opengl/gl_rasterizer_cache.cpp +++ b/src/video_core/renderer_opengl/gl_rasterizer_cache.cpp @@ -798,12 +798,58 @@ Surface RasterizerCacheOpenGL::RecreateSurface(const Surface& surface, // Verify surface is compatible for blitting const auto& params{surface->GetSurfaceParams()}; ASSERT(params.type == new_params.type); + ASSERT_MSG(params.GetCompressionFactor(params.pixel_format) == 1, + "Compressed texture reinterpretation is not supported"); // Create a new surface with the new parameters, and blit the previous surface to it Surface new_surface{std::make_shared(new_params)}; - BlitTextures(surface->Texture().handle, params.GetRect(), new_surface->Texture().handle, - new_surface->GetSurfaceParams().GetRect(), params.type, read_framebuffer.handle, - draw_framebuffer.handle); + + auto source_format = GetFormatTuple(params.pixel_format, params.component_type); + auto dest_format = GetFormatTuple(new_params.pixel_format, new_params.component_type); + + size_t buffer_size = std::max(params.SizeInBytes(), new_params.SizeInBytes()); + + // Use a Pixel Buffer Object to download the previous texture and then upload it to the new one + // using the new format. + OGLBuffer pbo; + pbo.Create(); + + glBindBuffer(GL_PIXEL_PACK_BUFFER, pbo.handle); + glBufferData(GL_PIXEL_PACK_BUFFER, buffer_size, nullptr, GL_STREAM_DRAW_ARB); + glGetTextureImage(surface->Texture().handle, 0, source_format.format, source_format.type, + params.SizeInBytes(), nullptr); + + // If the new texture is bigger than the previous one, we need to fill in the rest with data + // from the CPU. + if (params.SizeInBytes() < new_params.SizeInBytes()) { + // Upload the rest of the memory. + if (new_params.is_tiled) { + // TODO(Subv): We might have to de-tile the subtexture and re-tile it with the rest of + // the data in this case. Games like Super Mario Odyssey seem to hit this case when + // drawing, it re-uses the memory of a previous texture as a bigger framebuffer but it + // doesn't clear it beforehand, the texture is already full of zeros. + LOG_CRITICAL(HW_GPU, "Trying to upload extra texture data from the CPU during " + "reinterpretation but the texture is tiled."); + } + size_t remaining_size = new_params.SizeInBytes() - params.SizeInBytes(); + auto address = Core::System::GetInstance().GPU().memory_manager->GpuToCpuAddress( + new_params.addr + params.SizeInBytes()); + std::vector data(remaining_size); + Memory::ReadBlock(*address, data.data(), data.size()); + glBufferSubData(GL_PIXEL_PACK_BUFFER, params.SizeInBytes(), remaining_size, data.data()); + } + + glBindBuffer(GL_PIXEL_PACK_BUFFER, 0); + + const auto& dest_rect{new_params.GetRect()}; + + glBindBuffer(GL_PIXEL_UNPACK_BUFFER, pbo.handle); + glTextureSubImage2D( + new_surface->Texture().handle, 0, 0, 0, static_cast(dest_rect.GetWidth()), + static_cast(dest_rect.GetHeight()), dest_format.format, dest_format.type, nullptr); + glBindBuffer(GL_PIXEL_UNPACK_BUFFER, 0); + + pbo.Release(); // Update cache accordingly UnregisterSurface(surface);