mirror of
https://github.com/dolphin-emu/dolphin.git
synced 2024-11-15 05:47:56 -07:00
80b453082d
This was because the shader uniforms between the pixel and vertex shaders were willingly left different, to avoid filling the vertex shader with unnecessary params. Turns out all backends are fine with this except OGL. The new behaviour is now much more consistent and well explained, the "default" shaders are the ones that always run, and the non default ones are the user selected ones (if any).
1067 lines
35 KiB
C++
1067 lines
35 KiB
C++
// Copyright 2014 Dolphin Emulator Project
|
|
// SPDX-License-Identifier: GPL-2.0-or-later
|
|
|
|
#include "VideoCommon/PostProcessing.h"
|
|
|
|
#include <sstream>
|
|
#include <string>
|
|
#include <string_view>
|
|
|
|
#include <fmt/format.h>
|
|
|
|
#include "Common/Assert.h"
|
|
#include "Common/CommonPaths.h"
|
|
#include "Common/CommonTypes.h"
|
|
#include "Common/FileSearch.h"
|
|
#include "Common/FileUtil.h"
|
|
#include "Common/IniFile.h"
|
|
#include "Common/Logging/Log.h"
|
|
#include "Common/MsgHandler.h"
|
|
#include "Common/StringUtil.h"
|
|
|
|
#include "VideoCommon/AbstractFramebuffer.h"
|
|
#include "VideoCommon/AbstractGfx.h"
|
|
#include "VideoCommon/AbstractPipeline.h"
|
|
#include "VideoCommon/AbstractShader.h"
|
|
#include "VideoCommon/AbstractTexture.h"
|
|
#include "VideoCommon/FramebufferManager.h"
|
|
#include "VideoCommon/Present.h"
|
|
#include "VideoCommon/ShaderCache.h"
|
|
#include "VideoCommon/VertexManagerBase.h"
|
|
#include "VideoCommon/VideoCommon.h"
|
|
#include "VideoCommon/VideoConfig.h"
|
|
|
|
namespace VideoCommon
|
|
{
|
|
static const char s_empty_pixel_shader[] = "void main() { SetOutput(Sample()); }\n";
|
|
static const char s_default_pixel_shader_name[] = "default_pre_post_process";
|
|
// Keep the highest quality possible to avoid losing quality on subtle gamma conversions.
|
|
// RGBA16F should have enough quality even if we store colors in gamma space on it.
|
|
static const AbstractTextureFormat s_intermediary_buffer_format = AbstractTextureFormat::RGBA16F;
|
|
|
|
bool LoadShaderFromFile(const std::string& shader, const std::string& sub_dir,
|
|
std::string& out_code)
|
|
{
|
|
std::string path = File::GetUserPath(D_SHADERS_IDX) + sub_dir + shader + ".glsl";
|
|
|
|
if (!File::Exists(path))
|
|
{
|
|
// Fallback to shared user dir
|
|
path = File::GetSysDirectory() + SHADERS_DIR DIR_SEP + sub_dir + shader + ".glsl";
|
|
}
|
|
|
|
if (!File::ReadFileToString(path, out_code))
|
|
{
|
|
out_code = "";
|
|
ERROR_LOG_FMT(VIDEO, "Post-processing shader not found: {}", path);
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
PostProcessingConfiguration::PostProcessingConfiguration() = default;
|
|
|
|
PostProcessingConfiguration::~PostProcessingConfiguration() = default;
|
|
|
|
void PostProcessingConfiguration::LoadShader(const std::string& shader)
|
|
{
|
|
// Load the shader from the configuration if there isn't one sent to us.
|
|
m_current_shader = shader;
|
|
if (shader.empty())
|
|
{
|
|
LoadDefaultShader();
|
|
return;
|
|
}
|
|
|
|
std::string sub_dir = "";
|
|
|
|
if (g_Config.stereo_mode == StereoMode::Anaglyph)
|
|
{
|
|
sub_dir = ANAGLYPH_DIR DIR_SEP;
|
|
}
|
|
else if (g_Config.stereo_mode == StereoMode::Passive)
|
|
{
|
|
sub_dir = PASSIVE_DIR DIR_SEP;
|
|
}
|
|
|
|
std::string code;
|
|
if (!LoadShaderFromFile(shader, sub_dir, code))
|
|
{
|
|
LoadDefaultShader();
|
|
return;
|
|
}
|
|
|
|
LoadOptions(code);
|
|
// Note that this will build the shaders with the custom options values users
|
|
// might have set in the settings
|
|
LoadOptionsConfiguration();
|
|
m_current_shader_code = code;
|
|
}
|
|
|
|
void PostProcessingConfiguration::LoadDefaultShader()
|
|
{
|
|
m_options.clear();
|
|
m_any_options_dirty = false;
|
|
m_current_shader = "";
|
|
m_current_shader_code = s_empty_pixel_shader;
|
|
}
|
|
|
|
void PostProcessingConfiguration::LoadOptions(const std::string& code)
|
|
{
|
|
const std::string config_start_delimiter = "[configuration]";
|
|
const std::string config_end_delimiter = "[/configuration]";
|
|
size_t configuration_start = code.find(config_start_delimiter);
|
|
size_t configuration_end = code.find(config_end_delimiter);
|
|
|
|
m_options.clear();
|
|
m_any_options_dirty = true;
|
|
|
|
if (configuration_start == std::string::npos || configuration_end == std::string::npos)
|
|
{
|
|
// Issue loading configuration or there isn't one.
|
|
return;
|
|
}
|
|
|
|
std::string configuration_string =
|
|
code.substr(configuration_start + config_start_delimiter.size(),
|
|
configuration_end - configuration_start - config_start_delimiter.size());
|
|
|
|
std::istringstream in(configuration_string);
|
|
|
|
struct GLSLStringOption
|
|
{
|
|
std::string m_type;
|
|
std::vector<std::pair<std::string, std::string>> m_options;
|
|
};
|
|
|
|
std::vector<GLSLStringOption> option_strings;
|
|
GLSLStringOption* current_strings = nullptr;
|
|
while (!in.eof())
|
|
{
|
|
std::string line_str;
|
|
if (std::getline(in, line_str))
|
|
{
|
|
std::string_view line = line_str;
|
|
|
|
#ifndef _WIN32
|
|
// Check for CRLF eol and convert it to LF
|
|
if (!line.empty() && line.at(line.size() - 1) == '\r')
|
|
line.remove_suffix(1);
|
|
#endif
|
|
|
|
if (!line.empty())
|
|
{
|
|
if (line[0] == '[')
|
|
{
|
|
size_t endpos = line.find("]");
|
|
|
|
if (endpos != std::string::npos)
|
|
{
|
|
// New section!
|
|
std::string_view sub = line.substr(1, endpos - 1);
|
|
option_strings.push_back({std::string(sub)});
|
|
current_strings = &option_strings.back();
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (current_strings)
|
|
{
|
|
std::string key, value;
|
|
Common::IniFile::ParseLine(line, &key, &value);
|
|
|
|
if (!(key.empty() && value.empty()))
|
|
current_strings->m_options.emplace_back(key, value);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
for (const auto& it : option_strings)
|
|
{
|
|
ConfigurationOption option;
|
|
option.m_dirty = true;
|
|
|
|
if (it.m_type == "OptionBool")
|
|
option.m_type = ConfigurationOption::OptionType::Bool;
|
|
else if (it.m_type == "OptionRangeFloat")
|
|
option.m_type = ConfigurationOption::OptionType::Float;
|
|
else if (it.m_type == "OptionRangeInteger")
|
|
option.m_type = ConfigurationOption::OptionType::Integer;
|
|
|
|
for (const auto& string_option : it.m_options)
|
|
{
|
|
if (string_option.first == "GUIName")
|
|
{
|
|
option.m_gui_name = string_option.second;
|
|
}
|
|
else if (string_option.first == "OptionName")
|
|
{
|
|
option.m_option_name = string_option.second;
|
|
}
|
|
else if (string_option.first == "DependentOption")
|
|
{
|
|
option.m_dependent_option = string_option.second;
|
|
}
|
|
else if (string_option.first == "MinValue" || string_option.first == "MaxValue" ||
|
|
string_option.first == "DefaultValue" || string_option.first == "StepAmount")
|
|
{
|
|
std::vector<s32>* output_integer = nullptr;
|
|
std::vector<float>* output_float = nullptr;
|
|
|
|
if (string_option.first == "MinValue")
|
|
{
|
|
output_integer = &option.m_integer_min_values;
|
|
output_float = &option.m_float_min_values;
|
|
}
|
|
else if (string_option.first == "MaxValue")
|
|
{
|
|
output_integer = &option.m_integer_max_values;
|
|
output_float = &option.m_float_max_values;
|
|
}
|
|
else if (string_option.first == "DefaultValue")
|
|
{
|
|
output_integer = &option.m_integer_values;
|
|
output_float = &option.m_float_values;
|
|
}
|
|
else if (string_option.first == "StepAmount")
|
|
{
|
|
output_integer = &option.m_integer_step_values;
|
|
output_float = &option.m_float_step_values;
|
|
}
|
|
|
|
if (option.m_type == ConfigurationOption::OptionType::Bool)
|
|
{
|
|
TryParse(string_option.second, &option.m_bool_value);
|
|
}
|
|
else if (option.m_type == ConfigurationOption::OptionType::Integer)
|
|
{
|
|
TryParseVector(string_option.second, output_integer);
|
|
if (output_integer->size() > 4)
|
|
output_integer->erase(output_integer->begin() + 4, output_integer->end());
|
|
}
|
|
else if (option.m_type == ConfigurationOption::OptionType::Float)
|
|
{
|
|
TryParseVector(string_option.second, output_float);
|
|
if (output_float->size() > 4)
|
|
output_float->erase(output_float->begin() + 4, output_float->end());
|
|
}
|
|
}
|
|
}
|
|
m_options[option.m_option_name] = option;
|
|
}
|
|
}
|
|
|
|
void PostProcessingConfiguration::LoadOptionsConfiguration()
|
|
{
|
|
Common::IniFile ini;
|
|
ini.Load(File::GetUserPath(F_DOLPHINCONFIG_IDX));
|
|
std::string section = m_current_shader + "-options";
|
|
|
|
// We already expect all the options to be marked as "dirty" when we reach here
|
|
for (auto& it : m_options)
|
|
{
|
|
switch (it.second.m_type)
|
|
{
|
|
case ConfigurationOption::OptionType::Bool:
|
|
ini.GetOrCreateSection(section)->Get(it.second.m_option_name, &it.second.m_bool_value,
|
|
it.second.m_bool_value);
|
|
break;
|
|
case ConfigurationOption::OptionType::Integer:
|
|
{
|
|
std::string value;
|
|
ini.GetOrCreateSection(section)->Get(it.second.m_option_name, &value);
|
|
if (!value.empty())
|
|
{
|
|
auto integer_values = it.second.m_integer_values;
|
|
if (TryParseVector(value, &integer_values))
|
|
{
|
|
it.second.m_integer_values = integer_values;
|
|
}
|
|
}
|
|
}
|
|
break;
|
|
case ConfigurationOption::OptionType::Float:
|
|
{
|
|
std::string value;
|
|
ini.GetOrCreateSection(section)->Get(it.second.m_option_name, &value);
|
|
if (!value.empty())
|
|
{
|
|
auto float_values = it.second.m_float_values;
|
|
if (TryParseVector(value, &float_values))
|
|
{
|
|
it.second.m_float_values = float_values;
|
|
}
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
void PostProcessingConfiguration::SaveOptionsConfiguration()
|
|
{
|
|
Common::IniFile ini;
|
|
ini.Load(File::GetUserPath(F_DOLPHINCONFIG_IDX));
|
|
std::string section = m_current_shader + "-options";
|
|
|
|
for (auto& it : m_options)
|
|
{
|
|
switch (it.second.m_type)
|
|
{
|
|
case ConfigurationOption::OptionType::Bool:
|
|
{
|
|
ini.GetOrCreateSection(section)->Set(it.second.m_option_name, it.second.m_bool_value);
|
|
}
|
|
break;
|
|
case ConfigurationOption::OptionType::Integer:
|
|
{
|
|
std::string value;
|
|
for (size_t i = 0; i < it.second.m_integer_values.size(); ++i)
|
|
{
|
|
value += fmt::format("{}{}", it.second.m_integer_values[i],
|
|
i == (it.second.m_integer_values.size() - 1) ? "" : ", ");
|
|
}
|
|
ini.GetOrCreateSection(section)->Set(it.second.m_option_name, value);
|
|
}
|
|
break;
|
|
case ConfigurationOption::OptionType::Float:
|
|
{
|
|
std::ostringstream value;
|
|
value.imbue(std::locale("C"));
|
|
|
|
for (size_t i = 0; i < it.second.m_float_values.size(); ++i)
|
|
{
|
|
value << it.second.m_float_values[i];
|
|
if (i != (it.second.m_float_values.size() - 1))
|
|
value << ", ";
|
|
}
|
|
ini.GetOrCreateSection(section)->Set(it.second.m_option_name, value.str());
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
ini.Save(File::GetUserPath(F_DOLPHINCONFIG_IDX));
|
|
}
|
|
|
|
void PostProcessingConfiguration::SetOptionf(const std::string& option, int index, float value)
|
|
{
|
|
auto it = m_options.find(option);
|
|
|
|
it->second.m_float_values[index] = value;
|
|
it->second.m_dirty = true;
|
|
m_any_options_dirty = true;
|
|
}
|
|
|
|
void PostProcessingConfiguration::SetOptioni(const std::string& option, int index, s32 value)
|
|
{
|
|
auto it = m_options.find(option);
|
|
|
|
it->second.m_integer_values[index] = value;
|
|
it->second.m_dirty = true;
|
|
m_any_options_dirty = true;
|
|
}
|
|
|
|
void PostProcessingConfiguration::SetOptionb(const std::string& option, bool value)
|
|
{
|
|
auto it = m_options.find(option);
|
|
|
|
it->second.m_bool_value = value;
|
|
it->second.m_dirty = true;
|
|
m_any_options_dirty = true;
|
|
}
|
|
|
|
PostProcessing::PostProcessing()
|
|
{
|
|
m_timer.Start();
|
|
}
|
|
|
|
PostProcessing::~PostProcessing()
|
|
{
|
|
m_timer.Stop();
|
|
}
|
|
|
|
static std::vector<std::string> GetShaders(const std::string& sub_dir = "")
|
|
{
|
|
std::vector<std::string> paths =
|
|
Common::DoFileSearch({File::GetUserPath(D_SHADERS_IDX) + sub_dir,
|
|
File::GetSysDirectory() + SHADERS_DIR DIR_SEP + sub_dir},
|
|
{".glsl"});
|
|
std::vector<std::string> result;
|
|
for (std::string path : paths)
|
|
{
|
|
std::string name;
|
|
SplitPath(path, nullptr, &name, nullptr);
|
|
if (name == s_default_pixel_shader_name)
|
|
continue;
|
|
result.push_back(name);
|
|
}
|
|
return result;
|
|
}
|
|
|
|
std::vector<std::string> PostProcessing::GetShaderList()
|
|
{
|
|
return GetShaders();
|
|
}
|
|
|
|
std::vector<std::string> PostProcessing::GetAnaglyphShaderList()
|
|
{
|
|
return GetShaders(ANAGLYPH_DIR DIR_SEP);
|
|
}
|
|
|
|
std::vector<std::string> PostProcessing::GetPassiveShaderList()
|
|
{
|
|
return GetShaders(PASSIVE_DIR DIR_SEP);
|
|
}
|
|
|
|
bool PostProcessing::Initialize(AbstractTextureFormat format)
|
|
{
|
|
m_framebuffer_format = format;
|
|
// CompilePixelShader() must be run first if configuration options are used.
|
|
// Otherwise the UBO has a different member list between vertex and pixel
|
|
// shaders, which is a link error on some backends.
|
|
if (!CompilePixelShader() || !CompileVertexShader() || !CompilePipeline())
|
|
return false;
|
|
|
|
return true;
|
|
}
|
|
|
|
void PostProcessing::RecompileShader()
|
|
{
|
|
// Note: for simplicity we already recompile all the shaders
|
|
// and pipelines even if there might not be need to.
|
|
|
|
m_default_pipeline.reset();
|
|
m_pipeline.reset();
|
|
m_default_pixel_shader.reset();
|
|
m_pixel_shader.reset();
|
|
m_default_vertex_shader.reset();
|
|
m_vertex_shader.reset();
|
|
if (!CompilePixelShader())
|
|
return;
|
|
if (!CompileVertexShader())
|
|
return;
|
|
|
|
CompilePipeline();
|
|
}
|
|
|
|
void PostProcessing::RecompilePipeline()
|
|
{
|
|
m_default_pipeline.reset();
|
|
m_pipeline.reset();
|
|
CompilePipeline();
|
|
}
|
|
|
|
bool PostProcessing::IsColorCorrectionActive() const
|
|
{
|
|
// We can skip the color correction pass if none of these settings are on
|
|
// (it might have still helped with gamma correct sampling, but it's not worth running it).
|
|
return g_ActiveConfig.color_correction.bCorrectColorSpace ||
|
|
g_ActiveConfig.color_correction.bCorrectGamma ||
|
|
m_framebuffer_format == AbstractTextureFormat::RGBA16F;
|
|
}
|
|
|
|
bool PostProcessing::NeedsIntermediaryBuffer() const
|
|
{
|
|
// If we have no user selected post process shader,
|
|
// there's no point in having an intermediary buffer doing nothing.
|
|
return !m_config.GetShader().empty();
|
|
}
|
|
|
|
void PostProcessing::BlitFromTexture(const MathUtil::Rectangle<int>& dst,
|
|
const MathUtil::Rectangle<int>& src,
|
|
const AbstractTexture* src_tex, int src_layer)
|
|
{
|
|
if (g_gfx->GetCurrentFramebuffer()->GetColorFormat() != m_framebuffer_format)
|
|
{
|
|
m_framebuffer_format = g_gfx->GetCurrentFramebuffer()->GetColorFormat();
|
|
RecompilePipeline();
|
|
}
|
|
|
|
// By default all source layers will be copied into the respective target layers
|
|
const bool copy_all_layers = src_layer < 0;
|
|
src_layer = std::max(src_layer, 0);
|
|
|
|
MathUtil::Rectangle<int> src_rect = src;
|
|
g_gfx->SetSamplerState(0, RenderState::GetLinearSamplerState());
|
|
g_gfx->SetSamplerState(1, RenderState::GetPointSamplerState());
|
|
g_gfx->SetTexture(0, src_tex);
|
|
g_gfx->SetTexture(1, src_tex);
|
|
|
|
const bool needs_color_correction = IsColorCorrectionActive();
|
|
// Rely on the default (bi)linear sampler with the default mode
|
|
// (it might not be gamma corrected).
|
|
const bool needs_resampling =
|
|
g_ActiveConfig.output_resampling_mode > OutputResamplingMode::Default;
|
|
const bool needs_intermediary_buffer = NeedsIntermediaryBuffer();
|
|
const bool needs_default_pipeline = needs_color_correction || needs_resampling;
|
|
const AbstractPipeline* final_pipeline = m_pipeline.get();
|
|
std::vector<u8>* uniform_staging_buffer = &m_default_uniform_staging_buffer;
|
|
bool default_uniform_staging_buffer = true;
|
|
const MathUtil::Rectangle<int> present_rect = g_presenter->GetTargetRectangle();
|
|
|
|
// Intermediary pass.
|
|
// We draw to a high quality intermediary texture for a couple reasons:
|
|
// -Consistently do high quality gamma corrected resampling (upscaling/downscaling)
|
|
// -Keep quality for gamma and gamut conversions, and HDR output
|
|
// (low bit depths lose too much quality with gamma conversions)
|
|
// -Keep the post process phase in linear space, to better operate with colors
|
|
if (m_default_pipeline && needs_default_pipeline && needs_intermediary_buffer)
|
|
{
|
|
AbstractFramebuffer* const previous_framebuffer = g_gfx->GetCurrentFramebuffer();
|
|
|
|
// We keep the min number of layers as the render target,
|
|
// as in case of OpenGL, the source FBX will have two layers,
|
|
// but we will render onto two separate frame buffers (one by one),
|
|
// so it would be a waste to allocate two layers (see "bUsesExplictQuadBuffering").
|
|
const u32 target_layers = copy_all_layers ? src_tex->GetLayers() : 1;
|
|
|
|
const u32 target_width =
|
|
needs_resampling ? present_rect.GetWidth() : static_cast<u32>(src_rect.GetWidth());
|
|
const u32 target_height =
|
|
needs_resampling ? present_rect.GetHeight() : static_cast<u32>(src_rect.GetHeight());
|
|
|
|
if (!m_intermediary_frame_buffer || !m_intermediary_color_texture ||
|
|
m_intermediary_color_texture.get()->GetWidth() != target_width ||
|
|
m_intermediary_color_texture.get()->GetHeight() != target_height ||
|
|
m_intermediary_color_texture.get()->GetLayers() != target_layers)
|
|
{
|
|
const TextureConfig intermediary_color_texture_config(
|
|
target_width, target_height, 1, target_layers, src_tex->GetSamples(),
|
|
s_intermediary_buffer_format, AbstractTextureFlag_RenderTarget);
|
|
m_intermediary_color_texture = g_gfx->CreateTexture(intermediary_color_texture_config,
|
|
"Intermediary post process texture");
|
|
|
|
m_intermediary_frame_buffer =
|
|
g_gfx->CreateFramebuffer(m_intermediary_color_texture.get(), nullptr);
|
|
}
|
|
|
|
g_gfx->SetFramebuffer(m_intermediary_frame_buffer.get());
|
|
|
|
FillUniformBuffer(src_rect, src_tex, src_layer, g_gfx->GetCurrentFramebuffer()->GetRect(),
|
|
present_rect, uniform_staging_buffer->data(), !default_uniform_staging_buffer,
|
|
true);
|
|
g_vertex_manager->UploadUtilityUniforms(uniform_staging_buffer->data(),
|
|
static_cast<u32>(uniform_staging_buffer->size()));
|
|
|
|
g_gfx->SetViewportAndScissor(g_gfx->ConvertFramebufferRectangle(
|
|
m_intermediary_color_texture->GetRect(), m_intermediary_frame_buffer.get()));
|
|
g_gfx->SetPipeline(m_default_pipeline.get());
|
|
g_gfx->Draw(0, 3);
|
|
|
|
g_gfx->SetFramebuffer(previous_framebuffer);
|
|
src_rect = m_intermediary_color_texture->GetRect();
|
|
src_tex = m_intermediary_color_texture.get();
|
|
g_gfx->SetTexture(0, src_tex);
|
|
g_gfx->SetTexture(1, src_tex);
|
|
// The "m_intermediary_color_texture" has already copied
|
|
// from the specified source layer onto its first one.
|
|
// If we query for a layer that the source texture doesn't have,
|
|
// it will fall back on the first one anyway.
|
|
src_layer = 0;
|
|
uniform_staging_buffer = &m_uniform_staging_buffer;
|
|
default_uniform_staging_buffer = false;
|
|
}
|
|
else
|
|
{
|
|
// If we have no custom user shader selected, and color correction
|
|
// is active, directly run the fixed pipeline shader instead of
|
|
// doing two passes, with the second one doing nothing useful.
|
|
if (m_default_pipeline && needs_default_pipeline)
|
|
{
|
|
final_pipeline = m_default_pipeline.get();
|
|
}
|
|
else
|
|
{
|
|
uniform_staging_buffer = &m_uniform_staging_buffer;
|
|
default_uniform_staging_buffer = false;
|
|
}
|
|
|
|
m_intermediary_frame_buffer.release();
|
|
m_intermediary_color_texture.release();
|
|
}
|
|
|
|
// TODO: ideally we'd do the user selected post process pass in the intermediary buffer in linear
|
|
// space (instead of gamma space), so the shaders could act more accurately (and sample in linear
|
|
// space), though that would break the look of some of current post processes we have, and thus is
|
|
// better avoided for now.
|
|
|
|
// Final pass, either a user selected shader or the default (fixed) shader.
|
|
if (final_pipeline)
|
|
{
|
|
FillUniformBuffer(src_rect, src_tex, src_layer, g_gfx->GetCurrentFramebuffer()->GetRect(),
|
|
present_rect, uniform_staging_buffer->data(), !default_uniform_staging_buffer,
|
|
false);
|
|
g_vertex_manager->UploadUtilityUniforms(uniform_staging_buffer->data(),
|
|
static_cast<u32>(uniform_staging_buffer->size()));
|
|
|
|
g_gfx->SetViewportAndScissor(
|
|
g_gfx->ConvertFramebufferRectangle(dst, g_gfx->GetCurrentFramebuffer()));
|
|
g_gfx->SetPipeline(final_pipeline);
|
|
g_gfx->Draw(0, 3);
|
|
}
|
|
}
|
|
|
|
std::string PostProcessing::GetUniformBufferHeader(bool user_post_process) const
|
|
{
|
|
std::ostringstream ss;
|
|
u32 unused_counter = 1;
|
|
ss << "UBO_BINDING(std140, 1) uniform PSBlock {\n";
|
|
|
|
// Builtin uniforms:
|
|
|
|
ss << " float4 resolution;\n"; // Source resolution
|
|
ss << " float4 target_resolution;\n";
|
|
ss << " float4 window_resolution;\n";
|
|
// How many horizontal and vertical stereo views do we have? (set to 1 when we use layers instead)
|
|
ss << " int2 stereo_views;\n";
|
|
ss << " float4 src_rect;\n";
|
|
// The first (but not necessarily only) source layer we target
|
|
ss << " int src_layer;\n";
|
|
ss << " uint time;\n";
|
|
ss << " int graphics_api;\n";
|
|
// If true, it's an intermediary buffer (including the first), if false, it's the final one
|
|
ss << " int intermediary_buffer;\n";
|
|
|
|
ss << " int resampling_method;\n";
|
|
ss << " int correct_color_space;\n";
|
|
ss << " int game_color_space;\n";
|
|
ss << " int correct_gamma;\n";
|
|
ss << " float game_gamma;\n";
|
|
ss << " int sdr_display_gamma_sRGB;\n";
|
|
ss << " float sdr_display_custom_gamma;\n";
|
|
ss << " int linear_space_output;\n";
|
|
ss << " int hdr_output;\n";
|
|
ss << " float hdr_paper_white_nits;\n";
|
|
ss << " float hdr_sdr_white_nits;\n";
|
|
|
|
if (user_post_process)
|
|
{
|
|
ss << "\n";
|
|
// Custom options/uniforms
|
|
for (const auto& it : m_config.GetOptions())
|
|
{
|
|
if (it.second.m_type == PostProcessingConfiguration::ConfigurationOption::OptionType::Bool)
|
|
{
|
|
ss << fmt::format(" int {};\n", it.first);
|
|
for (u32 i = 0; i < 3; i++)
|
|
ss << " int ubo_align_" << unused_counter++ << "_;\n";
|
|
}
|
|
else if (it.second.m_type ==
|
|
PostProcessingConfiguration::ConfigurationOption::OptionType::Integer)
|
|
{
|
|
u32 count = static_cast<u32>(it.second.m_integer_values.size());
|
|
if (count == 1)
|
|
ss << fmt::format(" int {};\n", it.first);
|
|
else
|
|
ss << fmt::format(" int{} {};\n", count, it.first);
|
|
|
|
for (u32 i = count; i < 4; i++)
|
|
ss << " int ubo_align_" << unused_counter++ << "_;\n";
|
|
}
|
|
else if (it.second.m_type ==
|
|
PostProcessingConfiguration::ConfigurationOption::OptionType::Float)
|
|
{
|
|
u32 count = static_cast<u32>(it.second.m_float_values.size());
|
|
if (count == 1)
|
|
ss << fmt::format(" float {};\n", it.first);
|
|
else
|
|
ss << fmt::format(" float{} {};\n", count, it.first);
|
|
|
|
for (u32 i = count; i < 4; i++)
|
|
ss << " float ubo_align_" << unused_counter++ << "_;\n";
|
|
}
|
|
}
|
|
}
|
|
|
|
ss << "};\n\n";
|
|
return ss.str();
|
|
}
|
|
|
|
std::string PostProcessing::GetHeader(bool user_post_process) const
|
|
{
|
|
std::ostringstream ss;
|
|
ss << GetUniformBufferHeader(user_post_process);
|
|
ss << "SAMPLER_BINDING(0) uniform sampler2DArray samp0;\n";
|
|
ss << "SAMPLER_BINDING(1) uniform sampler2DArray samp1;\n";
|
|
|
|
if (g_ActiveConfig.backend_info.bSupportsGeometryShaders)
|
|
{
|
|
ss << "VARYING_LOCATION(0) in VertexData {\n";
|
|
ss << " float3 v_tex0;\n";
|
|
ss << "};\n";
|
|
}
|
|
else
|
|
{
|
|
ss << "VARYING_LOCATION(0) in float3 v_tex0;\n";
|
|
}
|
|
|
|
ss << "FRAGMENT_OUTPUT_LOCATION(0) out float4 ocol0;\n";
|
|
|
|
ss << R"(
|
|
float4 Sample() { return texture(samp0, v_tex0); }
|
|
float4 SampleLocation(float2 location) { return texture(samp0, float3(location, float(v_tex0.z))); }
|
|
float4 SampleLayer(int layer) { return texture(samp0, float3(v_tex0.xy, float(layer))); }
|
|
#define SampleOffset(offset) textureOffset(samp0, v_tex0, offset)
|
|
|
|
float2 GetTargetResolution()
|
|
{
|
|
return target_resolution.xy;
|
|
}
|
|
|
|
float2 GetInvTargetResolution()
|
|
{
|
|
return target_resolution.zw;
|
|
}
|
|
|
|
float2 GetWindowResolution()
|
|
{
|
|
return window_resolution.xy;
|
|
}
|
|
|
|
float2 GetInvWindowResolution()
|
|
{
|
|
return window_resolution.zw;
|
|
}
|
|
|
|
float2 GetResolution()
|
|
{
|
|
return resolution.xy;
|
|
}
|
|
|
|
float2 GetInvResolution()
|
|
{
|
|
return resolution.zw;
|
|
}
|
|
|
|
float2 GetCoordinates()
|
|
{
|
|
return v_tex0.xy;
|
|
}
|
|
|
|
float GetLayer()
|
|
{
|
|
return v_tex0.z;
|
|
}
|
|
|
|
uint GetTime()
|
|
{
|
|
return time;
|
|
}
|
|
|
|
void SetOutput(float4 color)
|
|
{
|
|
ocol0 = color;
|
|
}
|
|
|
|
#define GetOption(x) (x)
|
|
#define OptionEnabled(x) ((x) != 0)
|
|
#define OptionDisabled(x) ((x) == 0)
|
|
|
|
)";
|
|
return ss.str();
|
|
}
|
|
|
|
std::string PostProcessing::GetFooter() const
|
|
{
|
|
return {};
|
|
}
|
|
|
|
std::string GetVertexShaderBody()
|
|
{
|
|
std::ostringstream ss;
|
|
if (g_ActiveConfig.backend_info.bSupportsGeometryShaders)
|
|
{
|
|
ss << "VARYING_LOCATION(0) out VertexData {\n";
|
|
ss << " float3 v_tex0;\n";
|
|
ss << "};\n";
|
|
}
|
|
else
|
|
{
|
|
ss << "VARYING_LOCATION(0) out float3 v_tex0;\n";
|
|
}
|
|
|
|
ss << "#define id gl_VertexID\n";
|
|
ss << "#define opos gl_Position\n";
|
|
ss << "void main() {\n";
|
|
ss << " v_tex0 = float3(float((id << 1) & 2), float(id & 2), 0.0f);\n";
|
|
ss << " opos = float4(v_tex0.xy * float2(2.0f, -2.0f) + float2(-1.0f, 1.0f), 0.0f, 1.0f);\n";
|
|
ss << " v_tex0 = float3(src_rect.xy + (src_rect.zw * v_tex0.xy), float(src_layer));\n";
|
|
|
|
// Vulkan Y needs to be inverted on every pass
|
|
if (g_ActiveConfig.backend_info.api_type == APIType::Vulkan)
|
|
{
|
|
ss << " opos.y = -opos.y;\n";
|
|
}
|
|
// OpenGL Y needs to be inverted in all passes except the last one
|
|
else if (g_ActiveConfig.backend_info.api_type == APIType::OpenGL)
|
|
{
|
|
ss << " if (intermediary_buffer != 0)\n";
|
|
ss << " opos.y = -opos.y;\n";
|
|
}
|
|
|
|
ss << "}\n";
|
|
return ss.str();
|
|
}
|
|
|
|
bool PostProcessing::CompileVertexShader()
|
|
{
|
|
std::ostringstream ss_default;
|
|
ss_default << GetUniformBufferHeader(false);
|
|
ss_default << GetVertexShaderBody();
|
|
m_default_vertex_shader = g_gfx->CreateShaderFromSource(ShaderStage::Vertex, ss_default.str(),
|
|
"Default post-processing vertex shader");
|
|
|
|
std::ostringstream ss;
|
|
ss << GetUniformBufferHeader(true);
|
|
ss << GetVertexShaderBody();
|
|
m_vertex_shader =
|
|
g_gfx->CreateShaderFromSource(ShaderStage::Vertex, ss.str(), "Post-processing vertex shader");
|
|
|
|
if (!m_default_vertex_shader || !m_vertex_shader)
|
|
{
|
|
PanicAlertFmt("Failed to compile post-processing vertex shader");
|
|
m_default_vertex_shader.reset();
|
|
m_vertex_shader.reset();
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
struct BuiltinUniforms
|
|
{
|
|
// bools need to be represented as "s32"
|
|
|
|
std::array<float, 4> source_resolution;
|
|
std::array<float, 4> target_resolution;
|
|
std::array<float, 4> window_resolution;
|
|
std::array<float, 4> stereo_views;
|
|
std::array<float, 4> src_rect;
|
|
s32 src_layer;
|
|
u32 time;
|
|
s32 graphics_api;
|
|
s32 intermediary_buffer;
|
|
s32 resampling_method;
|
|
s32 correct_color_space;
|
|
s32 game_color_space;
|
|
s32 correct_gamma;
|
|
float game_gamma;
|
|
s32 sdr_display_gamma_sRGB;
|
|
float sdr_display_custom_gamma;
|
|
s32 linear_space_output;
|
|
s32 hdr_output;
|
|
float hdr_paper_white_nits;
|
|
float hdr_sdr_white_nits;
|
|
};
|
|
|
|
size_t PostProcessing::CalculateUniformsSize(bool user_post_process) const
|
|
{
|
|
// Allocate a vec4 for each uniform to simplify allocation.
|
|
return sizeof(BuiltinUniforms) +
|
|
(user_post_process ? m_config.GetOptions().size() : 0) * sizeof(float) * 4;
|
|
}
|
|
|
|
void PostProcessing::FillUniformBuffer(const MathUtil::Rectangle<int>& src,
|
|
const AbstractTexture* src_tex, int src_layer,
|
|
const MathUtil::Rectangle<int>& dst,
|
|
const MathUtil::Rectangle<int>& wnd, u8* buffer,
|
|
bool user_post_process, bool intermediary_buffer)
|
|
{
|
|
const float rcp_src_width = 1.0f / src_tex->GetWidth();
|
|
const float rcp_src_height = 1.0f / src_tex->GetHeight();
|
|
|
|
BuiltinUniforms builtin_uniforms;
|
|
builtin_uniforms.source_resolution = {static_cast<float>(src_tex->GetWidth()),
|
|
static_cast<float>(src_tex->GetHeight()), rcp_src_width,
|
|
rcp_src_height};
|
|
builtin_uniforms.target_resolution = {
|
|
static_cast<float>(dst.GetWidth()), static_cast<float>(dst.GetHeight()),
|
|
1.0f / static_cast<float>(dst.GetWidth()), 1.0f / static_cast<float>(dst.GetHeight())};
|
|
builtin_uniforms.window_resolution = {
|
|
static_cast<float>(wnd.GetWidth()), static_cast<float>(wnd.GetHeight()),
|
|
1.0f / static_cast<float>(wnd.GetWidth()), 1.0f / static_cast<float>(wnd.GetHeight())};
|
|
builtin_uniforms.src_rect = {static_cast<float>(src.left) * rcp_src_width,
|
|
static_cast<float>(src.top) * rcp_src_height,
|
|
static_cast<float>(src.GetWidth()) * rcp_src_width,
|
|
static_cast<float>(src.GetHeight()) * rcp_src_height};
|
|
builtin_uniforms.src_layer = static_cast<s32>(src_layer);
|
|
builtin_uniforms.time = static_cast<u32>(m_timer.ElapsedMs());
|
|
builtin_uniforms.graphics_api = static_cast<s32>(g_ActiveConfig.backend_info.api_type);
|
|
builtin_uniforms.intermediary_buffer = static_cast<s32>(intermediary_buffer);
|
|
|
|
builtin_uniforms.resampling_method = static_cast<s32>(g_ActiveConfig.output_resampling_mode);
|
|
// Color correction related uniforms.
|
|
// These are mainly used by the "m_default_pixel_shader",
|
|
// but should also be accessible to all other shaders.
|
|
builtin_uniforms.correct_color_space = g_ActiveConfig.color_correction.bCorrectColorSpace;
|
|
builtin_uniforms.game_color_space =
|
|
static_cast<int>(g_ActiveConfig.color_correction.game_color_space);
|
|
builtin_uniforms.correct_gamma = g_ActiveConfig.color_correction.bCorrectGamma;
|
|
builtin_uniforms.game_gamma = g_ActiveConfig.color_correction.fGameGamma;
|
|
builtin_uniforms.sdr_display_gamma_sRGB = g_ActiveConfig.color_correction.bSDRDisplayGammaSRGB;
|
|
builtin_uniforms.sdr_display_custom_gamma =
|
|
g_ActiveConfig.color_correction.fSDRDisplayCustomGamma;
|
|
// scRGB (RGBA16F) expects linear values as opposed to sRGB gamma
|
|
builtin_uniforms.linear_space_output = m_framebuffer_format == AbstractTextureFormat::RGBA16F;
|
|
// Implies ouput values can be beyond the 0-1 range
|
|
builtin_uniforms.hdr_output = m_framebuffer_format == AbstractTextureFormat::RGBA16F;
|
|
builtin_uniforms.hdr_paper_white_nits = g_ActiveConfig.color_correction.fHDRPaperWhiteNits;
|
|
// A value of 1 1 1 usually matches 80 nits in HDR
|
|
builtin_uniforms.hdr_sdr_white_nits = 80.f;
|
|
|
|
std::memcpy(buffer, &builtin_uniforms, sizeof(builtin_uniforms));
|
|
buffer += sizeof(builtin_uniforms);
|
|
|
|
// Don't include the custom pp shader options if they are not necessary,
|
|
// having mismatching uniforms between different shaders can cause issues on some backends
|
|
if (!user_post_process)
|
|
return;
|
|
|
|
for (auto& it : m_config.GetOptions())
|
|
{
|
|
union
|
|
{
|
|
u32 as_bool[4];
|
|
s32 as_int[4];
|
|
float as_float[4];
|
|
} value = {};
|
|
|
|
switch (it.second.m_type)
|
|
{
|
|
case PostProcessingConfiguration::ConfigurationOption::OptionType::Bool:
|
|
value.as_bool[0] = it.second.m_bool_value ? 1 : 0;
|
|
break;
|
|
|
|
case PostProcessingConfiguration::ConfigurationOption::OptionType::Integer:
|
|
ASSERT(it.second.m_integer_values.size() <= 4);
|
|
std::copy_n(it.second.m_integer_values.begin(), it.second.m_integer_values.size(),
|
|
value.as_int);
|
|
break;
|
|
|
|
case PostProcessingConfiguration::ConfigurationOption::OptionType::Float:
|
|
ASSERT(it.second.m_float_values.size() <= 4);
|
|
std::copy_n(it.second.m_float_values.begin(), it.second.m_float_values.size(),
|
|
value.as_float);
|
|
break;
|
|
}
|
|
|
|
it.second.m_dirty = false;
|
|
|
|
std::memcpy(buffer, &value, sizeof(value));
|
|
buffer += sizeof(value);
|
|
}
|
|
|
|
m_config.SetDirty(false);
|
|
}
|
|
|
|
bool PostProcessing::CompilePixelShader()
|
|
{
|
|
m_default_pixel_shader.reset();
|
|
m_pixel_shader.reset();
|
|
|
|
// Generate GLSL and compile the new shaders:
|
|
|
|
std::string default_pixel_shader_code;
|
|
if (LoadShaderFromFile(s_default_pixel_shader_name, "", default_pixel_shader_code))
|
|
{
|
|
m_default_pixel_shader = g_gfx->CreateShaderFromSource(
|
|
ShaderStage::Pixel, GetHeader(false) + default_pixel_shader_code + GetFooter(),
|
|
"Default post-processing pixel shader");
|
|
// We continue even if all of this failed, it doesn't matter
|
|
m_default_uniform_staging_buffer.resize(CalculateUniformsSize(false));
|
|
}
|
|
else
|
|
{
|
|
m_default_uniform_staging_buffer.resize(0);
|
|
}
|
|
|
|
m_config.LoadShader(g_ActiveConfig.sPostProcessingShader);
|
|
m_pixel_shader = g_gfx->CreateShaderFromSource(
|
|
ShaderStage::Pixel, GetHeader(true) + m_config.GetShaderCode() + GetFooter(),
|
|
fmt::format("User post-processing pixel shader: {}", m_config.GetShader()));
|
|
if (!m_pixel_shader)
|
|
{
|
|
PanicAlertFmt("Failed to compile user post-processing shader {}", m_config.GetShader());
|
|
|
|
// Use default shader.
|
|
m_config.LoadDefaultShader();
|
|
m_pixel_shader = g_gfx->CreateShaderFromSource(
|
|
ShaderStage::Pixel, GetHeader(true) + m_config.GetShaderCode() + GetFooter(),
|
|
"Default user post-processing pixel shader");
|
|
if (!m_pixel_shader)
|
|
{
|
|
m_uniform_staging_buffer.resize(0);
|
|
return false;
|
|
}
|
|
}
|
|
|
|
m_uniform_staging_buffer.resize(CalculateUniformsSize(true));
|
|
return true;
|
|
}
|
|
|
|
bool UseGeometryShaderForPostProcess(bool is_intermediary_buffer)
|
|
{
|
|
// We only return true on stereo modes that need to copy
|
|
// both source texture layers into the target texture layers.
|
|
// Any other case is handled manually with multiple copies, thus
|
|
// it doesn't need a geom shader.
|
|
switch (g_ActiveConfig.stereo_mode)
|
|
{
|
|
case StereoMode::QuadBuffer:
|
|
return !g_ActiveConfig.backend_info.bUsesExplictQuadBuffering;
|
|
case StereoMode::Anaglyph:
|
|
case StereoMode::Passive:
|
|
return is_intermediary_buffer;
|
|
case StereoMode::SBS:
|
|
case StereoMode::TAB:
|
|
case StereoMode::Off:
|
|
default:
|
|
return false;
|
|
}
|
|
}
|
|
|
|
bool PostProcessing::CompilePipeline()
|
|
{
|
|
// Not needed. Some backends don't like making pipelines with no targets,
|
|
// and in any case, we don't need to render anything if that happened.
|
|
if (m_framebuffer_format == AbstractTextureFormat::Undefined)
|
|
return true;
|
|
|
|
// If this is true, the "m_default_pipeline" won't be the only one that runs
|
|
const bool needs_intermediary_buffer = NeedsIntermediaryBuffer();
|
|
|
|
AbstractPipelineConfig config = {};
|
|
config.vertex_shader = m_default_vertex_shader.get();
|
|
// This geometry shader will take care of reading both layer 0 and 1 on the source texture,
|
|
// and writing to both layer 0 and 1 on the render target.
|
|
config.geometry_shader = UseGeometryShaderForPostProcess(needs_intermediary_buffer) ?
|
|
g_shader_cache->GetTexcoordGeometryShader() :
|
|
nullptr;
|
|
config.pixel_shader = m_default_pixel_shader.get();
|
|
config.rasterization_state = RenderState::GetNoCullRasterizationState(PrimitiveType::Triangles);
|
|
config.depth_state = RenderState::GetNoDepthTestingDepthState();
|
|
config.blending_state = RenderState::GetNoBlendingBlendState();
|
|
config.framebuffer_state = RenderState::GetColorFramebufferState(
|
|
needs_intermediary_buffer ? s_intermediary_buffer_format : m_framebuffer_format);
|
|
config.usage = AbstractPipelineUsage::Utility;
|
|
// We continue even if it failed, it will be skipped later on
|
|
if (config.pixel_shader)
|
|
m_default_pipeline = g_gfx->CreatePipeline(config);
|
|
|
|
config.vertex_shader = m_vertex_shader.get();
|
|
config.geometry_shader = UseGeometryShaderForPostProcess(false) ?
|
|
g_shader_cache->GetTexcoordGeometryShader() :
|
|
nullptr;
|
|
config.pixel_shader = m_pixel_shader.get();
|
|
config.framebuffer_state = RenderState::GetColorFramebufferState(m_framebuffer_format);
|
|
m_pipeline = g_gfx->CreatePipeline(config);
|
|
if (!m_pipeline)
|
|
return false;
|
|
|
|
return true;
|
|
}
|
|
} // namespace VideoCommon
|