Liam
2 years ago
6 changed files with 639 additions and 577 deletions
-
2src/video_core/CMakeLists.txt
-
519src/video_core/renderer_opengl/gl_blit_screen.cpp
-
110src/video_core/renderer_opengl/gl_blit_screen.h
-
1src/video_core/renderer_opengl/gl_rasterizer.h
-
506src/video_core/renderer_opengl/renderer_opengl.cpp
-
78src/video_core/renderer_opengl/renderer_opengl.h
@ -0,0 +1,519 @@ |
|||||
|
// SPDX-FileCopyrightText: Copyright 2024 yuzu Emulator Project
|
||||
|
// SPDX-License-Identifier: GPL-2.0-or-later
|
||||
|
|
||||
|
#include "video_core/framebuffer_config.h"
|
||||
|
#include "video_core/host_shaders/ffx_a_h.h"
|
||||
|
#include "video_core/host_shaders/ffx_fsr1_h.h"
|
||||
|
#include "video_core/host_shaders/full_screen_triangle_vert.h"
|
||||
|
#include "video_core/host_shaders/fxaa_frag.h"
|
||||
|
#include "video_core/host_shaders/fxaa_vert.h"
|
||||
|
#include "video_core/host_shaders/opengl_fidelityfx_fsr_easu_frag.h"
|
||||
|
#include "video_core/host_shaders/opengl_fidelityfx_fsr_frag.h"
|
||||
|
#include "video_core/host_shaders/opengl_fidelityfx_fsr_rcas_frag.h"
|
||||
|
#include "video_core/host_shaders/opengl_present_frag.h"
|
||||
|
#include "video_core/host_shaders/opengl_present_scaleforce_frag.h"
|
||||
|
#include "video_core/host_shaders/opengl_present_vert.h"
|
||||
|
#include "video_core/host_shaders/opengl_smaa_glsl.h"
|
||||
|
#include "video_core/host_shaders/present_bicubic_frag.h"
|
||||
|
#include "video_core/host_shaders/present_gaussian_frag.h"
|
||||
|
#include "video_core/host_shaders/smaa_blending_weight_calculation_frag.h"
|
||||
|
#include "video_core/host_shaders/smaa_blending_weight_calculation_vert.h"
|
||||
|
#include "video_core/host_shaders/smaa_edge_detection_frag.h"
|
||||
|
#include "video_core/host_shaders/smaa_edge_detection_vert.h"
|
||||
|
#include "video_core/host_shaders/smaa_neighborhood_blending_frag.h"
|
||||
|
#include "video_core/host_shaders/smaa_neighborhood_blending_vert.h"
|
||||
|
#include "video_core/renderer_opengl/gl_blit_screen.h"
|
||||
|
#include "video_core/renderer_opengl/gl_rasterizer.h"
|
||||
|
#include "video_core/renderer_opengl/gl_shader_manager.h"
|
||||
|
#include "video_core/renderer_opengl/gl_shader_util.h"
|
||||
|
#include "video_core/renderer_opengl/gl_state_tracker.h"
|
||||
|
#include "video_core/smaa_area_tex.h"
|
||||
|
#include "video_core/smaa_search_tex.h"
|
||||
|
#include "video_core/textures/decoders.h"
|
||||
|
|
||||
|
namespace OpenGL { |
||||
|
|
||||
|
namespace { |
||||
|
constexpr GLint PositionLocation = 0; |
||||
|
constexpr GLint TexCoordLocation = 1; |
||||
|
constexpr GLint ModelViewMatrixLocation = 0; |
||||
|
|
||||
|
struct ScreenRectVertex { |
||||
|
constexpr ScreenRectVertex(u32 x, u32 y, GLfloat u, GLfloat v) |
||||
|
: position{{static_cast<GLfloat>(x), static_cast<GLfloat>(y)}}, tex_coord{{u, v}} {} |
||||
|
|
||||
|
std::array<GLfloat, 2> position; |
||||
|
std::array<GLfloat, 2> tex_coord; |
||||
|
}; |
||||
|
|
||||
|
/**
|
||||
|
* Defines a 1:1 pixel ortographic projection matrix with (0,0) on the top-left |
||||
|
* corner and (width, height) on the lower-bottom. |
||||
|
* |
||||
|
* The projection part of the matrix is trivial, hence these operations are represented |
||||
|
* by a 3x2 matrix. |
||||
|
*/ |
||||
|
std::array<GLfloat, 3 * 2> MakeOrthographicMatrix(float width, float height) { |
||||
|
std::array<GLfloat, 3 * 2> matrix; // Laid out in column-major order
|
||||
|
|
||||
|
// clang-format off
|
||||
|
matrix[0] = 2.f / width; matrix[2] = 0.f; matrix[4] = -1.f; |
||||
|
matrix[1] = 0.f; matrix[3] = -2.f / height; matrix[5] = 1.f; |
||||
|
// Last matrix row is implicitly assumed to be [0, 0, 1].
|
||||
|
// clang-format on
|
||||
|
|
||||
|
return matrix; |
||||
|
} |
||||
|
} // namespace
|
||||
|
|
||||
|
BlitScreen::BlitScreen(RasterizerOpenGL& rasterizer_, |
||||
|
Tegra::MaxwellDeviceMemoryManager& device_memory_, |
||||
|
StateTracker& state_tracker_, ProgramManager& program_manager_, |
||||
|
Device& device_) |
||||
|
: rasterizer(rasterizer_), device_memory(device_memory_), state_tracker(state_tracker_), |
||||
|
program_manager(program_manager_), device(device_) { |
||||
|
// Create shader programs
|
||||
|
fxaa_vertex = CreateProgram(HostShaders::FXAA_VERT, GL_VERTEX_SHADER); |
||||
|
fxaa_fragment = CreateProgram(HostShaders::FXAA_FRAG, GL_FRAGMENT_SHADER); |
||||
|
|
||||
|
const auto replace_include = [](std::string& shader_source, std::string_view include_name, |
||||
|
std::string_view include_content) { |
||||
|
const std::string include_string = fmt::format("#include \"{}\"", include_name); |
||||
|
const std::size_t pos = shader_source.find(include_string); |
||||
|
ASSERT(pos != std::string::npos); |
||||
|
shader_source.replace(pos, include_string.size(), include_content); |
||||
|
}; |
||||
|
|
||||
|
const auto SmaaShader = [&](std::string_view specialized_source, GLenum stage) { |
||||
|
std::string shader_source{specialized_source}; |
||||
|
replace_include(shader_source, "opengl_smaa.glsl", HostShaders::OPENGL_SMAA_GLSL); |
||||
|
return CreateProgram(shader_source, stage); |
||||
|
}; |
||||
|
|
||||
|
smaa_edge_detection_vert = SmaaShader(HostShaders::SMAA_EDGE_DETECTION_VERT, GL_VERTEX_SHADER); |
||||
|
smaa_edge_detection_frag = |
||||
|
SmaaShader(HostShaders::SMAA_EDGE_DETECTION_FRAG, GL_FRAGMENT_SHADER); |
||||
|
smaa_blending_weight_calculation_vert = |
||||
|
SmaaShader(HostShaders::SMAA_BLENDING_WEIGHT_CALCULATION_VERT, GL_VERTEX_SHADER); |
||||
|
smaa_blending_weight_calculation_frag = |
||||
|
SmaaShader(HostShaders::SMAA_BLENDING_WEIGHT_CALCULATION_FRAG, GL_FRAGMENT_SHADER); |
||||
|
smaa_neighborhood_blending_vert = |
||||
|
SmaaShader(HostShaders::SMAA_NEIGHBORHOOD_BLENDING_VERT, GL_VERTEX_SHADER); |
||||
|
smaa_neighborhood_blending_frag = |
||||
|
SmaaShader(HostShaders::SMAA_NEIGHBORHOOD_BLENDING_FRAG, GL_FRAGMENT_SHADER); |
||||
|
|
||||
|
present_vertex = CreateProgram(HostShaders::OPENGL_PRESENT_VERT, GL_VERTEX_SHADER); |
||||
|
present_bilinear_fragment = CreateProgram(HostShaders::OPENGL_PRESENT_FRAG, GL_FRAGMENT_SHADER); |
||||
|
present_bicubic_fragment = CreateProgram(HostShaders::PRESENT_BICUBIC_FRAG, GL_FRAGMENT_SHADER); |
||||
|
present_gaussian_fragment = |
||||
|
CreateProgram(HostShaders::PRESENT_GAUSSIAN_FRAG, GL_FRAGMENT_SHADER); |
||||
|
present_scaleforce_fragment = |
||||
|
CreateProgram(fmt::format("#version 460\n{}", HostShaders::OPENGL_PRESENT_SCALEFORCE_FRAG), |
||||
|
GL_FRAGMENT_SHADER); |
||||
|
|
||||
|
std::string fsr_source{HostShaders::OPENGL_FIDELITYFX_FSR_FRAG}; |
||||
|
replace_include(fsr_source, "ffx_a.h", HostShaders::FFX_A_H); |
||||
|
replace_include(fsr_source, "ffx_fsr1.h", HostShaders::FFX_FSR1_H); |
||||
|
|
||||
|
std::string fsr_easu_frag_source{HostShaders::OPENGL_FIDELITYFX_FSR_EASU_FRAG}; |
||||
|
std::string fsr_rcas_frag_source{HostShaders::OPENGL_FIDELITYFX_FSR_RCAS_FRAG}; |
||||
|
replace_include(fsr_easu_frag_source, "opengl_fidelityfx_fsr.frag", fsr_source); |
||||
|
replace_include(fsr_rcas_frag_source, "opengl_fidelityfx_fsr.frag", fsr_source); |
||||
|
|
||||
|
fsr = std::make_unique<FSR>(HostShaders::FULL_SCREEN_TRIANGLE_VERT, fsr_easu_frag_source, |
||||
|
fsr_rcas_frag_source); |
||||
|
|
||||
|
// Generate presentation sampler
|
||||
|
present_sampler.Create(); |
||||
|
glSamplerParameteri(present_sampler.handle, GL_TEXTURE_MIN_FILTER, GL_LINEAR); |
||||
|
glSamplerParameteri(present_sampler.handle, GL_TEXTURE_MAG_FILTER, GL_LINEAR); |
||||
|
glSamplerParameteri(present_sampler.handle, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE); |
||||
|
glSamplerParameteri(present_sampler.handle, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE); |
||||
|
glSamplerParameteri(present_sampler.handle, GL_TEXTURE_WRAP_R, GL_CLAMP_TO_EDGE); |
||||
|
|
||||
|
present_sampler_nn.Create(); |
||||
|
glSamplerParameteri(present_sampler_nn.handle, GL_TEXTURE_MIN_FILTER, GL_NEAREST); |
||||
|
glSamplerParameteri(present_sampler_nn.handle, GL_TEXTURE_MAG_FILTER, GL_NEAREST); |
||||
|
glSamplerParameteri(present_sampler_nn.handle, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE); |
||||
|
glSamplerParameteri(present_sampler_nn.handle, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE); |
||||
|
glSamplerParameteri(present_sampler_nn.handle, GL_TEXTURE_WRAP_R, GL_CLAMP_TO_EDGE); |
||||
|
|
||||
|
// Generate VBO handle for drawing
|
||||
|
vertex_buffer.Create(); |
||||
|
|
||||
|
// Attach vertex data to VAO
|
||||
|
glNamedBufferData(vertex_buffer.handle, sizeof(ScreenRectVertex) * 4, nullptr, GL_STREAM_DRAW); |
||||
|
|
||||
|
// Allocate textures for the screen
|
||||
|
framebuffer_texture.resource.Create(GL_TEXTURE_2D); |
||||
|
|
||||
|
const GLuint texture = framebuffer_texture.resource.handle; |
||||
|
glTextureStorage2D(texture, 1, GL_RGBA8, 1, 1); |
||||
|
|
||||
|
// Clear screen to black
|
||||
|
const u8 framebuffer_data[4] = {0, 0, 0, 0}; |
||||
|
glClearTexImage(framebuffer_texture.resource.handle, 0, GL_RGBA, GL_UNSIGNED_BYTE, |
||||
|
framebuffer_data); |
||||
|
|
||||
|
aa_framebuffer.Create(); |
||||
|
|
||||
|
smaa_area_tex.Create(GL_TEXTURE_2D); |
||||
|
glTextureStorage2D(smaa_area_tex.handle, 1, GL_RG8, AREATEX_WIDTH, AREATEX_HEIGHT); |
||||
|
glTextureSubImage2D(smaa_area_tex.handle, 0, 0, 0, AREATEX_WIDTH, AREATEX_HEIGHT, GL_RG, |
||||
|
GL_UNSIGNED_BYTE, areaTexBytes); |
||||
|
smaa_search_tex.Create(GL_TEXTURE_2D); |
||||
|
glTextureStorage2D(smaa_search_tex.handle, 1, GL_R8, SEARCHTEX_WIDTH, SEARCHTEX_HEIGHT); |
||||
|
glTextureSubImage2D(smaa_search_tex.handle, 0, 0, 0, SEARCHTEX_WIDTH, SEARCHTEX_HEIGHT, GL_RED, |
||||
|
GL_UNSIGNED_BYTE, searchTexBytes); |
||||
|
|
||||
|
// Enable unified vertex attributes and query vertex buffer address when the driver supports it
|
||||
|
if (device.HasVertexBufferUnifiedMemory()) { |
||||
|
glEnableClientState(GL_VERTEX_ATTRIB_ARRAY_UNIFIED_NV); |
||||
|
glEnableClientState(GL_ELEMENT_ARRAY_UNIFIED_NV); |
||||
|
glMakeNamedBufferResidentNV(vertex_buffer.handle, GL_READ_ONLY); |
||||
|
glGetNamedBufferParameterui64vNV(vertex_buffer.handle, GL_BUFFER_GPU_ADDRESS_NV, |
||||
|
&vertex_buffer_address); |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
FramebufferTextureInfo BlitScreen::PrepareRenderTarget( |
||||
|
const Tegra::FramebufferConfig& framebuffer) { |
||||
|
// If framebuffer is provided, reload it from memory to a texture
|
||||
|
if (framebuffer_texture.width != static_cast<GLsizei>(framebuffer.width) || |
||||
|
framebuffer_texture.height != static_cast<GLsizei>(framebuffer.height) || |
||||
|
framebuffer_texture.pixel_format != framebuffer.pixel_format || |
||||
|
gl_framebuffer_data.empty()) { |
||||
|
// Reallocate texture if the framebuffer size has changed.
|
||||
|
// This is expected to not happen very often and hence should not be a
|
||||
|
// performance problem.
|
||||
|
ConfigureFramebufferTexture(framebuffer); |
||||
|
} |
||||
|
|
||||
|
// Load the framebuffer from memory if needed
|
||||
|
return LoadFBToScreenInfo(framebuffer); |
||||
|
} |
||||
|
|
||||
|
FramebufferTextureInfo BlitScreen::LoadFBToScreenInfo(const Tegra::FramebufferConfig& framebuffer) { |
||||
|
const DAddr framebuffer_addr{framebuffer.address + framebuffer.offset}; |
||||
|
const auto accelerated_info = |
||||
|
rasterizer.AccelerateDisplay(framebuffer, framebuffer_addr, framebuffer.stride); |
||||
|
if (accelerated_info) { |
||||
|
return *accelerated_info; |
||||
|
} |
||||
|
|
||||
|
// Reset the screen info's display texture to its own permanent texture
|
||||
|
FramebufferTextureInfo info{}; |
||||
|
info.display_texture = framebuffer_texture.resource.handle; |
||||
|
info.width = framebuffer.width; |
||||
|
info.height = framebuffer.height; |
||||
|
info.scaled_width = framebuffer.width; |
||||
|
info.scaled_height = framebuffer.height; |
||||
|
|
||||
|
// TODO(Rodrigo): Read this from HLE
|
||||
|
constexpr u32 block_height_log2 = 4; |
||||
|
const auto pixel_format{ |
||||
|
VideoCore::Surface::PixelFormatFromGPUPixelFormat(framebuffer.pixel_format)}; |
||||
|
const u32 bytes_per_pixel{VideoCore::Surface::BytesPerBlock(pixel_format)}; |
||||
|
const u64 size_in_bytes{Tegra::Texture::CalculateSize( |
||||
|
true, bytes_per_pixel, framebuffer.stride, framebuffer.height, 1, block_height_log2, 0)}; |
||||
|
const u8* const host_ptr{device_memory.GetPointer<u8>(framebuffer_addr)}; |
||||
|
const std::span<const u8> input_data(host_ptr, size_in_bytes); |
||||
|
Tegra::Texture::UnswizzleTexture(gl_framebuffer_data, input_data, bytes_per_pixel, |
||||
|
framebuffer.width, framebuffer.height, 1, block_height_log2, |
||||
|
0); |
||||
|
|
||||
|
glBindBuffer(GL_PIXEL_UNPACK_BUFFER, 0); |
||||
|
glPixelStorei(GL_UNPACK_ROW_LENGTH, static_cast<GLint>(framebuffer.stride)); |
||||
|
|
||||
|
// Update existing texture
|
||||
|
// TODO: Test what happens on hardware when you change the framebuffer dimensions so that
|
||||
|
// they differ from the LCD resolution.
|
||||
|
// TODO: Applications could theoretically crash yuzu here by specifying too large
|
||||
|
// framebuffer sizes. We should make sure that this cannot happen.
|
||||
|
glTextureSubImage2D(framebuffer_texture.resource.handle, 0, 0, 0, framebuffer.width, |
||||
|
framebuffer.height, framebuffer_texture.gl_format, |
||||
|
framebuffer_texture.gl_type, gl_framebuffer_data.data()); |
||||
|
|
||||
|
glPixelStorei(GL_UNPACK_ROW_LENGTH, 0); |
||||
|
|
||||
|
return info; |
||||
|
} |
||||
|
|
||||
|
void BlitScreen::ConfigureFramebufferTexture(const Tegra::FramebufferConfig& framebuffer) { |
||||
|
framebuffer_texture.width = framebuffer.width; |
||||
|
framebuffer_texture.height = framebuffer.height; |
||||
|
framebuffer_texture.pixel_format = framebuffer.pixel_format; |
||||
|
|
||||
|
const auto pixel_format{ |
||||
|
VideoCore::Surface::PixelFormatFromGPUPixelFormat(framebuffer.pixel_format)}; |
||||
|
const u32 bytes_per_pixel{VideoCore::Surface::BytesPerBlock(pixel_format)}; |
||||
|
gl_framebuffer_data.resize(framebuffer_texture.width * framebuffer_texture.height * |
||||
|
bytes_per_pixel); |
||||
|
|
||||
|
GLint internal_format; |
||||
|
switch (framebuffer.pixel_format) { |
||||
|
case Service::android::PixelFormat::Rgba8888: |
||||
|
internal_format = GL_RGBA8; |
||||
|
framebuffer_texture.gl_format = GL_RGBA; |
||||
|
framebuffer_texture.gl_type = GL_UNSIGNED_INT_8_8_8_8_REV; |
||||
|
break; |
||||
|
case Service::android::PixelFormat::Rgb565: |
||||
|
internal_format = GL_RGB565; |
||||
|
framebuffer_texture.gl_format = GL_RGB; |
||||
|
framebuffer_texture.gl_type = GL_UNSIGNED_SHORT_5_6_5; |
||||
|
break; |
||||
|
default: |
||||
|
internal_format = GL_RGBA8; |
||||
|
framebuffer_texture.gl_format = GL_RGBA; |
||||
|
framebuffer_texture.gl_type = GL_UNSIGNED_INT_8_8_8_8_REV; |
||||
|
// UNIMPLEMENTED_MSG("Unknown framebuffer pixel format: {}",
|
||||
|
// static_cast<u32>(framebuffer.pixel_format));
|
||||
|
break; |
||||
|
} |
||||
|
|
||||
|
framebuffer_texture.resource.Release(); |
||||
|
framebuffer_texture.resource.Create(GL_TEXTURE_2D); |
||||
|
glTextureStorage2D(framebuffer_texture.resource.handle, 1, internal_format, |
||||
|
framebuffer_texture.width, framebuffer_texture.height); |
||||
|
aa_texture.Release(); |
||||
|
aa_texture.Create(GL_TEXTURE_2D); |
||||
|
glTextureStorage2D(aa_texture.handle, 1, GL_RGBA16F, |
||||
|
Settings::values.resolution_info.ScaleUp(framebuffer_texture.width), |
||||
|
Settings::values.resolution_info.ScaleUp(framebuffer_texture.height)); |
||||
|
glNamedFramebufferTexture(aa_framebuffer.handle, GL_COLOR_ATTACHMENT0, aa_texture.handle, 0); |
||||
|
smaa_edges_tex.Release(); |
||||
|
smaa_edges_tex.Create(GL_TEXTURE_2D); |
||||
|
glTextureStorage2D(smaa_edges_tex.handle, 1, GL_RG16F, |
||||
|
Settings::values.resolution_info.ScaleUp(framebuffer_texture.width), |
||||
|
Settings::values.resolution_info.ScaleUp(framebuffer_texture.height)); |
||||
|
smaa_blend_tex.Release(); |
||||
|
smaa_blend_tex.Create(GL_TEXTURE_2D); |
||||
|
glTextureStorage2D(smaa_blend_tex.handle, 1, GL_RGBA16F, |
||||
|
Settings::values.resolution_info.ScaleUp(framebuffer_texture.width), |
||||
|
Settings::values.resolution_info.ScaleUp(framebuffer_texture.height)); |
||||
|
} |
||||
|
|
||||
|
void BlitScreen::DrawScreen(const Tegra::FramebufferConfig& framebuffer, |
||||
|
const Layout::FramebufferLayout& layout) { |
||||
|
FramebufferTextureInfo info = PrepareRenderTarget(framebuffer); |
||||
|
const auto crop = Tegra::NormalizeCrop(framebuffer, info.width, info.height); |
||||
|
|
||||
|
// TODO: Signal state tracker about these changes
|
||||
|
state_tracker.NotifyScreenDrawVertexArray(); |
||||
|
state_tracker.NotifyPolygonModes(); |
||||
|
state_tracker.NotifyViewport0(); |
||||
|
state_tracker.NotifyScissor0(); |
||||
|
state_tracker.NotifyColorMask(0); |
||||
|
state_tracker.NotifyBlend0(); |
||||
|
state_tracker.NotifyFramebuffer(); |
||||
|
state_tracker.NotifyFrontFace(); |
||||
|
state_tracker.NotifyCullTest(); |
||||
|
state_tracker.NotifyDepthTest(); |
||||
|
state_tracker.NotifyStencilTest(); |
||||
|
state_tracker.NotifyPolygonOffset(); |
||||
|
state_tracker.NotifyRasterizeEnable(); |
||||
|
state_tracker.NotifyFramebufferSRGB(); |
||||
|
state_tracker.NotifyLogicOp(); |
||||
|
state_tracker.NotifyClipControl(); |
||||
|
state_tracker.NotifyAlphaTest(); |
||||
|
|
||||
|
state_tracker.ClipControl(GL_LOWER_LEFT, GL_ZERO_TO_ONE); |
||||
|
|
||||
|
glEnable(GL_CULL_FACE); |
||||
|
glDisable(GL_COLOR_LOGIC_OP); |
||||
|
glDisable(GL_DEPTH_TEST); |
||||
|
glDisable(GL_STENCIL_TEST); |
||||
|
glDisable(GL_POLYGON_OFFSET_FILL); |
||||
|
glDisable(GL_RASTERIZER_DISCARD); |
||||
|
glDisable(GL_ALPHA_TEST); |
||||
|
glDisablei(GL_BLEND, 0); |
||||
|
glPolygonMode(GL_FRONT_AND_BACK, GL_FILL); |
||||
|
glCullFace(GL_BACK); |
||||
|
glFrontFace(GL_CW); |
||||
|
glColorMaski(0, GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE); |
||||
|
glDepthRangeIndexed(0, 0.0, 0.0); |
||||
|
|
||||
|
glBindTextureUnit(0, info.display_texture); |
||||
|
|
||||
|
auto anti_aliasing = Settings::values.anti_aliasing.GetValue(); |
||||
|
if (anti_aliasing >= Settings::AntiAliasing::MaxEnum) { |
||||
|
LOG_ERROR(Render_OpenGL, "Invalid antialiasing option selected {}", anti_aliasing); |
||||
|
anti_aliasing = Settings::AntiAliasing::None; |
||||
|
Settings::values.anti_aliasing.SetValue(anti_aliasing); |
||||
|
} |
||||
|
|
||||
|
if (anti_aliasing != Settings::AntiAliasing::None) { |
||||
|
glEnablei(GL_SCISSOR_TEST, 0); |
||||
|
auto scissor_width = Settings::values.resolution_info.ScaleUp(framebuffer_texture.width); |
||||
|
auto viewport_width = static_cast<GLfloat>(scissor_width); |
||||
|
auto scissor_height = Settings::values.resolution_info.ScaleUp(framebuffer_texture.height); |
||||
|
auto viewport_height = static_cast<GLfloat>(scissor_height); |
||||
|
|
||||
|
glScissorIndexed(0, 0, 0, scissor_width, scissor_height); |
||||
|
glViewportIndexedf(0, 0.0f, 0.0f, viewport_width, viewport_height); |
||||
|
|
||||
|
glBindSampler(0, present_sampler.handle); |
||||
|
GLint old_read_fb; |
||||
|
GLint old_draw_fb; |
||||
|
glGetIntegerv(GL_READ_FRAMEBUFFER_BINDING, &old_read_fb); |
||||
|
glGetIntegerv(GL_DRAW_FRAMEBUFFER_BINDING, &old_draw_fb); |
||||
|
|
||||
|
switch (anti_aliasing) { |
||||
|
case Settings::AntiAliasing::Fxaa: { |
||||
|
program_manager.BindPresentPrograms(fxaa_vertex.handle, fxaa_fragment.handle); |
||||
|
glBindFramebuffer(GL_DRAW_FRAMEBUFFER, aa_framebuffer.handle); |
||||
|
glDrawArrays(GL_TRIANGLE_STRIP, 0, 4); |
||||
|
} break; |
||||
|
case Settings::AntiAliasing::Smaa: { |
||||
|
glClearColor(0, 0, 0, 0); |
||||
|
glFrontFace(GL_CCW); |
||||
|
glBindFramebuffer(GL_DRAW_FRAMEBUFFER, aa_framebuffer.handle); |
||||
|
glBindSampler(1, present_sampler.handle); |
||||
|
glBindSampler(2, present_sampler.handle); |
||||
|
|
||||
|
glNamedFramebufferTexture(aa_framebuffer.handle, GL_COLOR_ATTACHMENT0, |
||||
|
smaa_edges_tex.handle, 0); |
||||
|
glClear(GL_COLOR_BUFFER_BIT); |
||||
|
program_manager.BindPresentPrograms(smaa_edge_detection_vert.handle, |
||||
|
smaa_edge_detection_frag.handle); |
||||
|
glDrawArrays(GL_TRIANGLES, 0, 3); |
||||
|
|
||||
|
glBindTextureUnit(0, smaa_edges_tex.handle); |
||||
|
glBindTextureUnit(1, smaa_area_tex.handle); |
||||
|
glBindTextureUnit(2, smaa_search_tex.handle); |
||||
|
glNamedFramebufferTexture(aa_framebuffer.handle, GL_COLOR_ATTACHMENT0, |
||||
|
smaa_blend_tex.handle, 0); |
||||
|
glClear(GL_COLOR_BUFFER_BIT); |
||||
|
program_manager.BindPresentPrograms(smaa_blending_weight_calculation_vert.handle, |
||||
|
smaa_blending_weight_calculation_frag.handle); |
||||
|
glDrawArrays(GL_TRIANGLES, 0, 3); |
||||
|
|
||||
|
glBindTextureUnit(0, info.display_texture); |
||||
|
glBindTextureUnit(1, smaa_blend_tex.handle); |
||||
|
glNamedFramebufferTexture(aa_framebuffer.handle, GL_COLOR_ATTACHMENT0, |
||||
|
aa_texture.handle, 0); |
||||
|
program_manager.BindPresentPrograms(smaa_neighborhood_blending_vert.handle, |
||||
|
smaa_neighborhood_blending_frag.handle); |
||||
|
glDrawArrays(GL_TRIANGLES, 0, 3); |
||||
|
glFrontFace(GL_CW); |
||||
|
} break; |
||||
|
default: |
||||
|
UNREACHABLE(); |
||||
|
} |
||||
|
|
||||
|
glBindFramebuffer(GL_READ_FRAMEBUFFER, old_read_fb); |
||||
|
glBindFramebuffer(GL_DRAW_FRAMEBUFFER, old_draw_fb); |
||||
|
|
||||
|
glBindTextureUnit(0, aa_texture.handle); |
||||
|
} |
||||
|
glDisablei(GL_SCISSOR_TEST, 0); |
||||
|
|
||||
|
if (Settings::values.scaling_filter.GetValue() == Settings::ScalingFilter::Fsr) { |
||||
|
if (!fsr->AreBuffersInitialized()) { |
||||
|
fsr->InitBuffers(); |
||||
|
} |
||||
|
|
||||
|
glBindSampler(0, present_sampler.handle); |
||||
|
fsr->Draw(program_manager, layout.screen, info.scaled_width, info.scaled_height, crop); |
||||
|
} else { |
||||
|
if (fsr->AreBuffersInitialized()) { |
||||
|
fsr->ReleaseBuffers(); |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
const std::array ortho_matrix = |
||||
|
MakeOrthographicMatrix(static_cast<float>(layout.width), static_cast<float>(layout.height)); |
||||
|
|
||||
|
const auto fragment_handle = [this]() { |
||||
|
switch (Settings::values.scaling_filter.GetValue()) { |
||||
|
case Settings::ScalingFilter::NearestNeighbor: |
||||
|
case Settings::ScalingFilter::Bilinear: |
||||
|
return present_bilinear_fragment.handle; |
||||
|
case Settings::ScalingFilter::Bicubic: |
||||
|
return present_bicubic_fragment.handle; |
||||
|
case Settings::ScalingFilter::Gaussian: |
||||
|
return present_gaussian_fragment.handle; |
||||
|
case Settings::ScalingFilter::ScaleForce: |
||||
|
return present_scaleforce_fragment.handle; |
||||
|
case Settings::ScalingFilter::Fsr: |
||||
|
return fsr->GetPresentFragmentProgram().handle; |
||||
|
default: |
||||
|
return present_bilinear_fragment.handle; |
||||
|
} |
||||
|
}(); |
||||
|
program_manager.BindPresentPrograms(present_vertex.handle, fragment_handle); |
||||
|
glProgramUniformMatrix3x2fv(present_vertex.handle, ModelViewMatrixLocation, 1, GL_FALSE, |
||||
|
ortho_matrix.data()); |
||||
|
|
||||
|
f32 left, top, right, bottom; |
||||
|
if (Settings::values.scaling_filter.GetValue() == Settings::ScalingFilter::Fsr) { |
||||
|
// FSR has already applied the crop, so we just want to render the image
|
||||
|
// it has produced.
|
||||
|
left = 0; |
||||
|
top = 0; |
||||
|
right = 1; |
||||
|
bottom = 1; |
||||
|
} else { |
||||
|
// Apply the precomputed crop.
|
||||
|
left = crop.left; |
||||
|
top = crop.top; |
||||
|
right = crop.right; |
||||
|
bottom = crop.bottom; |
||||
|
} |
||||
|
|
||||
|
// Map the coordinates to the screen.
|
||||
|
const auto& screen = layout.screen; |
||||
|
const auto x = screen.left; |
||||
|
const auto y = screen.top; |
||||
|
const auto w = screen.GetWidth(); |
||||
|
const auto h = screen.GetHeight(); |
||||
|
|
||||
|
const std::array vertices = { |
||||
|
ScreenRectVertex(x, y, left, top), |
||||
|
ScreenRectVertex(x + w, y, right, top), |
||||
|
ScreenRectVertex(x, y + h, left, bottom), |
||||
|
ScreenRectVertex(x + w, y + h, right, bottom), |
||||
|
}; |
||||
|
glNamedBufferSubData(vertex_buffer.handle, 0, sizeof(vertices), std::data(vertices)); |
||||
|
|
||||
|
glDisable(GL_FRAMEBUFFER_SRGB); |
||||
|
glViewportIndexedf(0, 0.0f, 0.0f, static_cast<GLfloat>(layout.width), |
||||
|
static_cast<GLfloat>(layout.height)); |
||||
|
|
||||
|
glEnableVertexAttribArray(PositionLocation); |
||||
|
glEnableVertexAttribArray(TexCoordLocation); |
||||
|
glVertexAttribDivisor(PositionLocation, 0); |
||||
|
glVertexAttribDivisor(TexCoordLocation, 0); |
||||
|
glVertexAttribFormat(PositionLocation, 2, GL_FLOAT, GL_FALSE, |
||||
|
offsetof(ScreenRectVertex, position)); |
||||
|
glVertexAttribFormat(TexCoordLocation, 2, GL_FLOAT, GL_FALSE, |
||||
|
offsetof(ScreenRectVertex, tex_coord)); |
||||
|
glVertexAttribBinding(PositionLocation, 0); |
||||
|
glVertexAttribBinding(TexCoordLocation, 0); |
||||
|
if (device.HasVertexBufferUnifiedMemory()) { |
||||
|
glBindVertexBuffer(0, 0, 0, sizeof(ScreenRectVertex)); |
||||
|
glBufferAddressRangeNV(GL_VERTEX_ATTRIB_ARRAY_ADDRESS_NV, 0, vertex_buffer_address, |
||||
|
sizeof(vertices)); |
||||
|
} else { |
||||
|
glBindVertexBuffer(0, vertex_buffer.handle, 0, sizeof(ScreenRectVertex)); |
||||
|
} |
||||
|
|
||||
|
if (Settings::values.scaling_filter.GetValue() != Settings::ScalingFilter::NearestNeighbor) { |
||||
|
glBindSampler(0, present_sampler.handle); |
||||
|
} else { |
||||
|
glBindSampler(0, present_sampler_nn.handle); |
||||
|
} |
||||
|
|
||||
|
// Update background color before drawing
|
||||
|
glClearColor(Settings::values.bg_red.GetValue() / 255.0f, |
||||
|
Settings::values.bg_green.GetValue() / 255.0f, |
||||
|
Settings::values.bg_blue.GetValue() / 255.0f, 1.0f); |
||||
|
|
||||
|
glClear(GL_COLOR_BUFFER_BIT); |
||||
|
glDrawArrays(GL_TRIANGLE_STRIP, 0, 4); |
||||
|
|
||||
|
// TODO
|
||||
|
// program_manager.RestoreGuestPipeline();
|
||||
|
} |
||||
|
|
||||
|
} // namespace OpenGL
|
||||
@ -0,0 +1,110 @@ |
|||||
|
// SPDX-FileCopyrightText: Copyright 2024 yuzu Emulator Project |
||||
|
// SPDX-License-Identifier: GPL-2.0-or-later |
||||
|
|
||||
|
#pragma once |
||||
|
|
||||
|
#include <memory> |
||||
|
#include <vector> |
||||
|
|
||||
|
#include "core/hle/service/nvnflinger/pixel_format.h" |
||||
|
#include "video_core/host1x/gpu_device_memory_manager.h" |
||||
|
#include "video_core/renderer_opengl/gl_fsr.h" |
||||
|
#include "video_core/renderer_opengl/gl_resource_manager.h" |
||||
|
|
||||
|
namespace Layout { |
||||
|
struct FramebufferLayout; |
||||
|
} |
||||
|
|
||||
|
namespace Tegra { |
||||
|
struct FramebufferConfig; |
||||
|
} |
||||
|
|
||||
|
namespace OpenGL { |
||||
|
|
||||
|
class Device; |
||||
|
class RasterizerOpenGL; |
||||
|
class StateTracker; |
||||
|
|
||||
|
/// Structure used for storing information about the textures for the Switch screen |
||||
|
struct TextureInfo { |
||||
|
OGLTexture resource; |
||||
|
GLsizei width; |
||||
|
GLsizei height; |
||||
|
GLenum gl_format; |
||||
|
GLenum gl_type; |
||||
|
Service::android::PixelFormat pixel_format; |
||||
|
}; |
||||
|
|
||||
|
/// Structure used for storing information about the display target for the Switch screen |
||||
|
struct FramebufferTextureInfo { |
||||
|
GLuint display_texture{}; |
||||
|
u32 width; |
||||
|
u32 height; |
||||
|
u32 scaled_width; |
||||
|
u32 scaled_height; |
||||
|
}; |
||||
|
|
||||
|
class BlitScreen { |
||||
|
public: |
||||
|
explicit BlitScreen(RasterizerOpenGL& rasterizer, |
||||
|
Tegra::MaxwellDeviceMemoryManager& device_memory, |
||||
|
StateTracker& state_tracker, ProgramManager& program_manager, |
||||
|
Device& device); |
||||
|
|
||||
|
void ConfigureFramebufferTexture(const Tegra::FramebufferConfig& framebuffer); |
||||
|
|
||||
|
/// Draws the emulated screens to the emulator window. |
||||
|
void DrawScreen(const Tegra::FramebufferConfig& framebuffer, |
||||
|
const Layout::FramebufferLayout& layout); |
||||
|
|
||||
|
void RenderScreenshot(const Tegra::FramebufferConfig& framebuffer); |
||||
|
|
||||
|
/// Loads framebuffer from emulated memory into the active OpenGL texture. |
||||
|
FramebufferTextureInfo LoadFBToScreenInfo(const Tegra::FramebufferConfig& framebuffer); |
||||
|
|
||||
|
FramebufferTextureInfo PrepareRenderTarget(const Tegra::FramebufferConfig& framebuffer); |
||||
|
|
||||
|
private: |
||||
|
RasterizerOpenGL& rasterizer; |
||||
|
Tegra::MaxwellDeviceMemoryManager& device_memory; |
||||
|
StateTracker& state_tracker; |
||||
|
ProgramManager& program_manager; |
||||
|
Device& device; |
||||
|
|
||||
|
OGLSampler present_sampler; |
||||
|
OGLSampler present_sampler_nn; |
||||
|
OGLBuffer vertex_buffer; |
||||
|
OGLProgram fxaa_vertex; |
||||
|
OGLProgram fxaa_fragment; |
||||
|
OGLProgram present_vertex; |
||||
|
OGLProgram present_bilinear_fragment; |
||||
|
OGLProgram present_bicubic_fragment; |
||||
|
OGLProgram present_gaussian_fragment; |
||||
|
OGLProgram present_scaleforce_fragment; |
||||
|
|
||||
|
/// Display information for Switch screen |
||||
|
TextureInfo framebuffer_texture; |
||||
|
OGLTexture aa_texture; |
||||
|
OGLFramebuffer aa_framebuffer; |
||||
|
|
||||
|
OGLProgram smaa_edge_detection_vert; |
||||
|
OGLProgram smaa_blending_weight_calculation_vert; |
||||
|
OGLProgram smaa_neighborhood_blending_vert; |
||||
|
OGLProgram smaa_edge_detection_frag; |
||||
|
OGLProgram smaa_blending_weight_calculation_frag; |
||||
|
OGLProgram smaa_neighborhood_blending_frag; |
||||
|
OGLTexture smaa_area_tex; |
||||
|
OGLTexture smaa_search_tex; |
||||
|
OGLTexture smaa_edges_tex; |
||||
|
OGLTexture smaa_blend_tex; |
||||
|
|
||||
|
std::unique_ptr<FSR> fsr; |
||||
|
|
||||
|
/// OpenGL framebuffer data |
||||
|
std::vector<u8> gl_framebuffer_data; |
||||
|
|
||||
|
// GPU address of the vertex buffer |
||||
|
GLuint64EXT vertex_buffer_address = 0; |
||||
|
}; |
||||
|
|
||||
|
} // namespace OpenGL |
||||
Write
Preview
Loading…
Cancel
Save
Reference in new issue