mirror of
https://github.com/RetroDECK/Duckstation.git
synced 2024-12-02 10:35:39 +00:00
758 lines
23 KiB
C++
758 lines
23 KiB
C++
// SPDX-FileCopyrightText: 2019-2023 Connor McLaughlin <stenzek@gmail.com>
|
|
// SPDX-License-Identifier: (GPL-3.0 OR CC-BY-NC-ND-4.0)
|
|
|
|
#include "postprocessing.h"
|
|
#include "gpu_device.h"
|
|
#include "host.h"
|
|
#include "imgui_manager.h"
|
|
#include "postprocessing_shader.h"
|
|
#include "postprocessing_shader_fx.h"
|
|
#include "postprocessing_shader_glsl.h"
|
|
|
|
// TODO: Remove me
|
|
#include "core/host.h"
|
|
#include "core/host_interface_progress_callback.h"
|
|
#include "core/settings.h"
|
|
|
|
#include "IconsFontAwesome5.h"
|
|
#include "common/assert.h"
|
|
#include "common/error.h"
|
|
#include "common/file_system.h"
|
|
#include "common/log.h"
|
|
#include "common/path.h"
|
|
#include "common/progress_callback.h"
|
|
#include "common/small_string.h"
|
|
#include "common/string_util.h"
|
|
#include "common/timer.h"
|
|
#include "fmt/format.h"
|
|
|
|
Log_SetChannel(PostProcessing);
|
|
|
|
// TODO: ProgressCallbacks for shader compiling, it can be a bit slow.
|
|
// TODO: buffer width/height is wrong on resize, need to change it somehow.
|
|
|
|
namespace PostProcessing {
|
|
template<typename T>
|
|
static u32 ParseVector(const std::string_view& line, ShaderOption::ValueVector* values);
|
|
|
|
static TinyString ValueToString(ShaderOption::Type type, u32 vector_size, const ShaderOption::ValueVector& value);
|
|
|
|
static TinyString GetStageConfigSection(u32 index);
|
|
static void CopyStageConfig(SettingsInterface& si, u32 old_index, u32 new_index);
|
|
static void SwapStageConfig(SettingsInterface& si, u32 lhs_index, u32 rhs_index);
|
|
static std::unique_ptr<Shader> TryLoadingShader(const std::string& shader_name, bool only_config, Error* error);
|
|
static void ClearStagesWithError(const Error& error);
|
|
static SettingsInterface& GetLoadSettingsInterface();
|
|
static void LoadStages();
|
|
static void DestroyTextures();
|
|
|
|
static std::vector<std::unique_ptr<PostProcessing::Shader>> s_stages;
|
|
static bool s_enabled = false;
|
|
|
|
static GPUTexture::Format s_target_format = GPUTexture::Format::Unknown;
|
|
static u32 s_target_width = 0;
|
|
static u32 s_target_height = 0;
|
|
static Common::Timer s_timer;
|
|
|
|
static std::unique_ptr<GPUTexture> s_input_texture;
|
|
|
|
static std::unique_ptr<GPUTexture> s_output_texture;
|
|
|
|
static std::unordered_map<u64, std::unique_ptr<GPUSampler>> s_samplers;
|
|
static std::unique_ptr<GPUTexture> s_dummy_texture;
|
|
} // namespace PostProcessing
|
|
|
|
template<typename T>
|
|
u32 PostProcessing::ParseVector(const std::string_view& line, ShaderOption::ValueVector* values)
|
|
{
|
|
u32 index = 0;
|
|
size_t start = 0;
|
|
while (index < PostProcessing::ShaderOption::MAX_VECTOR_COMPONENTS)
|
|
{
|
|
while (start < line.size() && std::isspace(line[start]))
|
|
start++;
|
|
|
|
if (start >= line.size())
|
|
break;
|
|
|
|
size_t end = line.find(',', start);
|
|
if (end == std::string_view::npos)
|
|
end = line.size();
|
|
|
|
const std::string_view component = line.substr(start, end - start);
|
|
T value = StringUtil::FromChars<T>(component).value_or(static_cast<T>(0));
|
|
if constexpr (std::is_same_v<T, float>)
|
|
(*values)[index++].float_value = value;
|
|
else if constexpr (std::is_same_v<T, s32>)
|
|
(*values)[index++].int_value = value;
|
|
|
|
start = end + 1;
|
|
}
|
|
|
|
const u32 size = index;
|
|
|
|
for (; index < PostProcessing::ShaderOption::MAX_VECTOR_COMPONENTS; index++)
|
|
{
|
|
if constexpr (std::is_same_v<T, float>)
|
|
(*values)[index++].float_value = 0.0f;
|
|
else if constexpr (std::is_same_v<T, s32>)
|
|
(*values)[index++].int_value = 0;
|
|
}
|
|
|
|
return size;
|
|
}
|
|
|
|
u32 PostProcessing::ShaderOption::ParseFloatVector(const std::string_view& line, ValueVector* values)
|
|
{
|
|
return ParseVector<float>(line, values);
|
|
}
|
|
|
|
u32 PostProcessing::ShaderOption::ParseIntVector(const std::string_view& line, ValueVector* values)
|
|
{
|
|
return ParseVector<s32>(line, values);
|
|
}
|
|
|
|
TinyString PostProcessing::ValueToString(ShaderOption::Type type, u32 vector_size,
|
|
const ShaderOption::ValueVector& value)
|
|
{
|
|
TinyString ret;
|
|
|
|
for (u32 i = 0; i < vector_size; i++)
|
|
{
|
|
if (i > 0)
|
|
ret.append(',');
|
|
|
|
switch (type)
|
|
{
|
|
case ShaderOption::Type::Bool:
|
|
ret.append((value[i].int_value != 0) ? "true" : "false");
|
|
break;
|
|
|
|
case ShaderOption::Type::Int:
|
|
ret.append_format("{}", value[i].int_value);
|
|
break;
|
|
|
|
case ShaderOption::Type::Float:
|
|
ret.append_format("{}", value[i].float_value);
|
|
break;
|
|
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
|
|
return ret;
|
|
}
|
|
|
|
std::vector<std::pair<std::string, std::string>> PostProcessing::GetAvailableShaderNames()
|
|
{
|
|
std::vector<std::pair<std::string, std::string>> names;
|
|
|
|
FileSystem::FindResultsArray results;
|
|
FileSystem::FindFiles(Path::Combine(EmuFolders::Resources, "shaders").c_str(), "*.glsl",
|
|
FILESYSTEM_FIND_FILES | FILESYSTEM_FIND_RECURSIVE | FILESYSTEM_FIND_RELATIVE_PATHS, &results);
|
|
FileSystem::FindFiles(EmuFolders::Shaders.c_str(), "*.glsl",
|
|
FILESYSTEM_FIND_FILES | FILESYSTEM_FIND_RECURSIVE | FILESYSTEM_FIND_RELATIVE_PATHS |
|
|
FILESYSTEM_FIND_KEEP_ARRAY,
|
|
&results);
|
|
std::sort(results.begin(), results.end(),
|
|
[](const auto& lhs, const auto& rhs) { return lhs.FileName < rhs.FileName; });
|
|
|
|
for (FILESYSTEM_FIND_DATA& fd : results)
|
|
{
|
|
size_t pos = fd.FileName.rfind('.');
|
|
if (pos != std::string::npos && pos > 0)
|
|
fd.FileName.erase(pos);
|
|
|
|
// swap any backslashes for forward slashes so the config is cross-platform
|
|
for (size_t i = 0; i < fd.FileName.size(); i++)
|
|
{
|
|
if (fd.FileName[i] == '\\')
|
|
fd.FileName[i] = '/';
|
|
}
|
|
|
|
if (std::none_of(names.begin(), names.end(), [&fd](const auto& other) { return fd.FileName == other.second; }))
|
|
{
|
|
std::string display_name = fmt::format(TRANSLATE_FS("PostProcessing", "{} [GLSL]"), fd.FileName);
|
|
names.emplace_back(std::move(display_name), std::move(fd.FileName));
|
|
}
|
|
}
|
|
|
|
FileSystem::FindFiles(Path::Combine(EmuFolders::Shaders, "reshade" FS_OSPATH_SEPARATOR_STR "Shaders").c_str(), "*.fx",
|
|
FILESYSTEM_FIND_FILES | FILESYSTEM_FIND_RELATIVE_PATHS, &results);
|
|
FileSystem::FindFiles(
|
|
Path::Combine(EmuFolders::Resources, "shaders" FS_OSPATH_SEPARATOR_STR "reshade" FS_OSPATH_SEPARATOR_STR "Shaders")
|
|
.c_str(),
|
|
"*.fx", FILESYSTEM_FIND_FILES | FILESYSTEM_FIND_RELATIVE_PATHS | FILESYSTEM_FIND_KEEP_ARRAY, &results);
|
|
std::sort(results.begin(), results.end(),
|
|
[](const auto& lhs, const auto& rhs) { return lhs.FileName < rhs.FileName; });
|
|
|
|
for (FILESYSTEM_FIND_DATA& fd : results)
|
|
{
|
|
size_t pos = fd.FileName.rfind('.');
|
|
if (pos != std::string::npos && pos > 0)
|
|
fd.FileName.erase(pos);
|
|
|
|
// swap any backslashes for forward slashes so the config is cross-platform
|
|
for (size_t i = 0; i < fd.FileName.size(); i++)
|
|
{
|
|
if (fd.FileName[i] == '\\')
|
|
fd.FileName[i] = '/';
|
|
}
|
|
|
|
if (std::none_of(names.begin(), names.end(), [&fd](const auto& other) { return fd.FileName == other.second; }))
|
|
{
|
|
std::string display_name = fmt::format(TRANSLATE_FS("PostProcessing", "{} [ReShade]"), fd.FileName);
|
|
names.emplace_back(std::move(display_name), std::move(fd.FileName));
|
|
}
|
|
}
|
|
|
|
return names;
|
|
}
|
|
|
|
TinyString PostProcessing::GetStageConfigSection(u32 index)
|
|
{
|
|
return TinyString::from_format("PostProcessing/Stage{}", index + 1);
|
|
}
|
|
|
|
void PostProcessing::CopyStageConfig(SettingsInterface& si, u32 old_index, u32 new_index)
|
|
{
|
|
const TinyString old_section = GetStageConfigSection(old_index);
|
|
const TinyString new_section = GetStageConfigSection(new_index);
|
|
|
|
si.ClearSection(new_section);
|
|
|
|
for (const auto& [key, value] : si.GetKeyValueList(old_section))
|
|
si.SetStringValue(new_section, key.c_str(), value.c_str());
|
|
}
|
|
|
|
void PostProcessing::SwapStageConfig(SettingsInterface& si, u32 lhs_index, u32 rhs_index)
|
|
{
|
|
const TinyString lhs_section = GetStageConfigSection(lhs_index);
|
|
const TinyString rhs_section = GetStageConfigSection(rhs_index);
|
|
|
|
const std::vector<std::pair<std::string, std::string>> lhs_kvs = si.GetKeyValueList(lhs_section);
|
|
si.ClearSection(lhs_section);
|
|
|
|
const std::vector<std::pair<std::string, std::string>> rhs_kvs = si.GetKeyValueList(rhs_section);
|
|
si.ClearSection(rhs_section);
|
|
|
|
for (const auto& [key, value] : rhs_kvs)
|
|
si.SetStringValue(lhs_section, key.c_str(), value.c_str());
|
|
|
|
for (const auto& [key, value] : lhs_kvs)
|
|
si.SetStringValue(rhs_section, key.c_str(), value.c_str());
|
|
}
|
|
|
|
u32 PostProcessing::Config::GetStageCount(const SettingsInterface& si)
|
|
{
|
|
return si.GetUIntValue("PostProcessing", "StageCount", 0u);
|
|
}
|
|
|
|
std::string PostProcessing::Config::GetStageShaderName(const SettingsInterface& si, u32 index)
|
|
{
|
|
return si.GetStringValue(GetStageConfigSection(index), "ShaderName");
|
|
}
|
|
|
|
std::vector<PostProcessing::ShaderOption> PostProcessing::Config::GetStageOptions(const SettingsInterface& si,
|
|
u32 index)
|
|
{
|
|
std::vector<PostProcessing::ShaderOption> ret;
|
|
|
|
const TinyString section = GetStageConfigSection(index);
|
|
const std::string shader_name = si.GetStringValue(section, "ShaderName");
|
|
if (shader_name.empty())
|
|
return ret;
|
|
|
|
std::unique_ptr<Shader> shader = TryLoadingShader(shader_name, true, nullptr);
|
|
if (!shader)
|
|
return ret;
|
|
|
|
shader->LoadOptions(si, section);
|
|
ret = shader->TakeOptions();
|
|
return ret;
|
|
}
|
|
|
|
std::vector<PostProcessing::ShaderOption> PostProcessing::Config::GetShaderOptions(const std::string& shader_name,
|
|
Error* error)
|
|
{
|
|
std::vector<PostProcessing::ShaderOption> ret;
|
|
std::unique_ptr<Shader> shader = TryLoadingShader(shader_name, true, error);
|
|
if (!shader)
|
|
return ret;
|
|
|
|
ret = shader->TakeOptions();
|
|
return ret;
|
|
}
|
|
|
|
bool PostProcessing::Config::AddStage(SettingsInterface& si, const std::string& shader_name, Error* error)
|
|
{
|
|
std::unique_ptr<Shader> shader = TryLoadingShader(shader_name, true, error);
|
|
if (!shader)
|
|
return false;
|
|
|
|
const u32 index = GetStageCount(si);
|
|
si.SetUIntValue("PostProcessing", "StageCount", index + 1);
|
|
|
|
const TinyString section = GetStageConfigSection(index);
|
|
si.SetStringValue(section, "ShaderName", shader->GetName().c_str());
|
|
|
|
#if 0
|
|
// Leave options unset for now.
|
|
for (const ShaderOption& option : shader->GetOptions())
|
|
{
|
|
si.SetStringValue(section, option.name.c_str(),
|
|
ValueToString(option.type, option.vector_size, option.default_value));
|
|
}
|
|
#endif
|
|
|
|
return true;
|
|
}
|
|
|
|
void PostProcessing::Config::RemoveStage(SettingsInterface& si, u32 index)
|
|
{
|
|
const u32 stage_count = GetStageCount(si);
|
|
if (index >= stage_count)
|
|
return;
|
|
|
|
for (u32 i = index; i < (stage_count - 1); i++)
|
|
CopyStageConfig(si, i + 1, i);
|
|
|
|
si.ClearSection(GetStageConfigSection(stage_count - 1));
|
|
si.SetUIntValue("PostProcessing", "StageCount", stage_count - 1);
|
|
}
|
|
|
|
void PostProcessing::Config::MoveStageUp(SettingsInterface& si, u32 index)
|
|
{
|
|
const u32 stage_count = GetStageCount(si);
|
|
if (index == 0 || index >= stage_count)
|
|
return;
|
|
|
|
SwapStageConfig(si, index, index - 1);
|
|
}
|
|
|
|
void PostProcessing::Config::MoveStageDown(SettingsInterface& si, u32 index)
|
|
{
|
|
const u32 stage_count = GetStageCount(si);
|
|
if ((index + 1) >= stage_count)
|
|
return;
|
|
|
|
SwapStageConfig(si, index, index + 1);
|
|
}
|
|
|
|
void PostProcessing::Config::SetStageOption(SettingsInterface& si, u32 index, const ShaderOption& option)
|
|
{
|
|
const TinyString section = GetStageConfigSection(index);
|
|
si.SetStringValue(section, option.name.c_str(), ValueToString(option.type, option.vector_size, option.value));
|
|
}
|
|
|
|
void PostProcessing::Config::UnsetStageOption(SettingsInterface& si, u32 index, const ShaderOption& option)
|
|
{
|
|
const TinyString section = GetStageConfigSection(index);
|
|
si.DeleteValue(section, option.name.c_str());
|
|
}
|
|
|
|
void PostProcessing::Config::ClearStages(SettingsInterface& si)
|
|
{
|
|
const u32 count = GetStageCount(si);
|
|
for (s32 i = static_cast<s32>(count - 1); i >= 0; i--)
|
|
si.ClearSection(GetStageConfigSection(static_cast<u32>(i)));
|
|
si.SetUIntValue("PostProcessing", "StageCount", 0);
|
|
}
|
|
|
|
bool PostProcessing::IsActive()
|
|
{
|
|
return s_enabled && !s_stages.empty();
|
|
}
|
|
|
|
bool PostProcessing::IsEnabled()
|
|
{
|
|
return s_enabled;
|
|
}
|
|
|
|
void PostProcessing::SetEnabled(bool enabled)
|
|
{
|
|
s_enabled = enabled;
|
|
}
|
|
|
|
std::unique_ptr<PostProcessing::Shader> PostProcessing::TryLoadingShader(const std::string& shader_name,
|
|
bool only_config, Error* error)
|
|
{
|
|
std::string filename;
|
|
std::optional<std::string> resource_str;
|
|
|
|
// Try reshade first.
|
|
filename = Path::Combine(
|
|
EmuFolders::Shaders,
|
|
fmt::format("reshade" FS_OSPATH_SEPARATOR_STR "Shaders" FS_OSPATH_SEPARATOR_STR "{}.fx", shader_name));
|
|
if (FileSystem::FileExists(filename.c_str()))
|
|
{
|
|
std::unique_ptr<ReShadeFXShader> shader = std::make_unique<ReShadeFXShader>();
|
|
if (shader->LoadFromFile(std::string(shader_name), filename.c_str(), only_config, error))
|
|
return shader;
|
|
}
|
|
|
|
filename = Path::Combine(EmuFolders::Shaders, fmt::format("{}.glsl", shader_name));
|
|
if (FileSystem::FileExists(filename.c_str()))
|
|
{
|
|
std::unique_ptr<GLSLShader> shader = std::make_unique<GLSLShader>();
|
|
if (shader->LoadFromFile(std::string(shader_name), filename.c_str(), error))
|
|
return shader;
|
|
}
|
|
|
|
filename =
|
|
fmt::format("shaders/reshade" FS_OSPATH_SEPARATOR_STR "Shaders" FS_OSPATH_SEPARATOR_STR "{}.fx", shader_name);
|
|
resource_str = Host::ReadResourceFileToString(filename.c_str(), true);
|
|
if (resource_str.has_value())
|
|
{
|
|
std::unique_ptr<ReShadeFXShader> shader = std::make_unique<ReShadeFXShader>();
|
|
if (shader->LoadFromString(std::string(shader_name), std::move(filename), std::move(resource_str.value()),
|
|
only_config, error))
|
|
{
|
|
return shader;
|
|
}
|
|
}
|
|
|
|
filename = fmt::format("shaders" FS_OSPATH_SEPARATOR_STR "{}.glsl", shader_name);
|
|
resource_str = Host::ReadResourceFileToString(filename.c_str(), true);
|
|
if (resource_str.has_value())
|
|
{
|
|
std::unique_ptr<GLSLShader> shader = std::make_unique<GLSLShader>();
|
|
if (shader->LoadFromString(std::string(shader_name), std::move(resource_str.value()), error))
|
|
return shader;
|
|
}
|
|
|
|
Log_ErrorFmt("Failed to load shader '{}'", shader_name);
|
|
return {};
|
|
}
|
|
|
|
void PostProcessing::ClearStagesWithError(const Error& error)
|
|
{
|
|
std::string msg = error.GetDescription();
|
|
Host::AddIconOSDMessage(
|
|
"PostProcessLoadFail", ICON_FA_EXCLAMATION_TRIANGLE,
|
|
fmt::format(TRANSLATE_FS("OSDMessage", "Failed to load post-processing chain: {}"),
|
|
msg.empty() ? TRANSLATE_SV("PostProcessing", "Unknown Error") : std::string_view(msg)),
|
|
Host::OSD_ERROR_DURATION);
|
|
s_stages.clear();
|
|
}
|
|
|
|
SettingsInterface& PostProcessing::GetLoadSettingsInterface()
|
|
{
|
|
// If PostProcessing/Enable is set in the game settings interface, use that.
|
|
// Otherwise, use the base settings.
|
|
|
|
SettingsInterface* game_si = Host::Internal::GetGameSettingsLayer();
|
|
if (game_si && game_si->ContainsValue("PostProcessing", "Enabled"))
|
|
return *game_si;
|
|
else
|
|
return *Host::Internal::GetBaseSettingsLayer();
|
|
}
|
|
|
|
void PostProcessing::Initialize()
|
|
{
|
|
LoadStages();
|
|
}
|
|
|
|
void PostProcessing::LoadStages()
|
|
{
|
|
auto lock = Host::GetSettingsLock();
|
|
SettingsInterface& si = GetLoadSettingsInterface();
|
|
|
|
s_enabled = si.GetBoolValue("PostProcessing", "Enabled", false);
|
|
|
|
const u32 stage_count = Config::GetStageCount(si);
|
|
if (stage_count == 0)
|
|
return;
|
|
|
|
Error error;
|
|
HostInterfaceProgressCallback progress;
|
|
progress.SetProgressRange(stage_count);
|
|
|
|
for (u32 i = 0; i < stage_count; i++)
|
|
{
|
|
std::string stage_name = Config::GetStageShaderName(si, i);
|
|
if (stage_name.empty())
|
|
{
|
|
error.SetString(fmt::format("No stage name in stage {}.", i + 1));
|
|
ClearStagesWithError(error);
|
|
return;
|
|
}
|
|
|
|
lock.unlock();
|
|
progress.SetFormattedStatusText("Loading shader %s...", stage_name.c_str());
|
|
|
|
std::unique_ptr<Shader> shader = TryLoadingShader(stage_name, false, &error);
|
|
if (!shader)
|
|
{
|
|
ClearStagesWithError(error);
|
|
return;
|
|
}
|
|
|
|
lock.lock();
|
|
shader->LoadOptions(si, GetStageConfigSection(i));
|
|
s_stages.push_back(std::move(shader));
|
|
|
|
progress.IncrementProgressValue();
|
|
}
|
|
|
|
if (stage_count > 0)
|
|
{
|
|
s_timer.Reset();
|
|
Log_DevPrintf("Loaded %u post-processing stages.", stage_count);
|
|
}
|
|
|
|
// precompile shaders
|
|
if (g_gpu_device && g_gpu_device->GetWindowFormat() != GPUTexture::Format::Unknown)
|
|
{
|
|
CheckTargets(g_gpu_device->GetWindowFormat(), g_gpu_device->GetWindowWidth(), g_gpu_device->GetWindowHeight(),
|
|
&progress);
|
|
}
|
|
}
|
|
|
|
void PostProcessing::UpdateSettings()
|
|
{
|
|
auto lock = Host::GetSettingsLock();
|
|
SettingsInterface& si = GetLoadSettingsInterface();
|
|
|
|
s_enabled = si.GetBoolValue("PostProcessing", "Enabled", false);
|
|
|
|
const u32 stage_count = Config::GetStageCount(si);
|
|
if (stage_count == 0)
|
|
{
|
|
s_stages.clear();
|
|
return;
|
|
}
|
|
|
|
Error error;
|
|
|
|
s_stages.resize(stage_count);
|
|
|
|
HostInterfaceProgressCallback progress;
|
|
progress.SetProgressRange(stage_count);
|
|
|
|
const GPUTexture::Format prev_format = s_target_format;
|
|
|
|
for (u32 i = 0; i < stage_count; i++)
|
|
{
|
|
std::string stage_name = Config::GetStageShaderName(si, i);
|
|
if (stage_name.empty())
|
|
{
|
|
error.SetString(fmt::format("No stage name in stage {}.", i + 1));
|
|
ClearStagesWithError(error);
|
|
return;
|
|
}
|
|
|
|
if (!s_stages[i] || stage_name != s_stages[i]->GetName())
|
|
{
|
|
if (i < s_stages.size())
|
|
s_stages[i].reset();
|
|
|
|
// Force recompile.
|
|
s_target_format = GPUTexture::Format::Unknown;
|
|
|
|
lock.unlock();
|
|
|
|
std::unique_ptr<Shader> shader = TryLoadingShader(stage_name, false, &error);
|
|
if (!shader)
|
|
{
|
|
ClearStagesWithError(error);
|
|
return;
|
|
}
|
|
|
|
if (i < s_stages.size())
|
|
s_stages[i] = std::move(shader);
|
|
else
|
|
s_stages.push_back(std::move(shader));
|
|
|
|
lock.lock();
|
|
}
|
|
|
|
s_stages[i]->LoadOptions(si, GetStageConfigSection(i));
|
|
}
|
|
|
|
if (prev_format != GPUTexture::Format::Unknown)
|
|
CheckTargets(prev_format, s_target_width, s_target_height, &progress);
|
|
|
|
if (stage_count > 0)
|
|
{
|
|
s_timer.Reset();
|
|
Log_DevPrintf("Loaded %u post-processing stages.", stage_count);
|
|
}
|
|
}
|
|
|
|
void PostProcessing::Toggle()
|
|
{
|
|
if (s_stages.empty())
|
|
{
|
|
Host::AddIconOSDMessage("PostProcessing", ICON_FA_PAINT_ROLLER,
|
|
TRANSLATE_STR("OSDMessage", "No post-processing shaders are selected."),
|
|
Host::OSD_QUICK_DURATION);
|
|
return;
|
|
}
|
|
|
|
const bool new_enabled = !s_enabled;
|
|
Host::AddIconOSDMessage("PostProcessing", ICON_FA_PAINT_ROLLER,
|
|
new_enabled ? TRANSLATE_STR("OSDMessage", "Post-processing is now enabled.") :
|
|
TRANSLATE_STR("OSDMessage", "Post-processing is now disabled."),
|
|
Host::OSD_QUICK_DURATION);
|
|
s_enabled = new_enabled;
|
|
if (s_enabled)
|
|
s_timer.Reset();
|
|
}
|
|
|
|
bool PostProcessing::ReloadShaders()
|
|
{
|
|
if (s_stages.empty())
|
|
{
|
|
Host::AddIconOSDMessage("PostProcessing", ICON_FA_PAINT_ROLLER,
|
|
TRANSLATE_STR("OSDMessage", "No post-processing shaders are selected."),
|
|
Host::OSD_QUICK_DURATION);
|
|
return false;
|
|
}
|
|
|
|
decltype(s_stages)().swap(s_stages);
|
|
DestroyTextures();
|
|
LoadStages();
|
|
|
|
Host::AddIconOSDMessage("PostProcessing", ICON_FA_PAINT_ROLLER,
|
|
TRANSLATE_STR("OSDMessage", "Post-processing shaders reloaded."), Host::OSD_QUICK_DURATION);
|
|
return true;
|
|
}
|
|
|
|
void PostProcessing::Shutdown()
|
|
{
|
|
g_gpu_device->RecycleTexture(std::move(s_dummy_texture));
|
|
s_samplers.clear();
|
|
s_enabled = false;
|
|
decltype(s_stages)().swap(s_stages);
|
|
DestroyTextures();
|
|
}
|
|
|
|
GPUTexture* PostProcessing::GetInputTexture()
|
|
{
|
|
return s_input_texture.get();
|
|
}
|
|
|
|
const Common::Timer& PostProcessing::GetTimer()
|
|
{
|
|
return s_timer;
|
|
}
|
|
|
|
GPUSampler* PostProcessing::GetSampler(const GPUSampler::Config& config)
|
|
{
|
|
auto it = s_samplers.find(config.key);
|
|
if (it != s_samplers.end())
|
|
return it->second.get();
|
|
|
|
std::unique_ptr<GPUSampler> sampler = g_gpu_device->CreateSampler(config);
|
|
if (!sampler)
|
|
Log_ErrorFmt("Failed to create GPU sampler with config={:X}", config.key);
|
|
|
|
it = s_samplers.emplace(config.key, std::move(sampler)).first;
|
|
return it->second.get();
|
|
}
|
|
|
|
GPUTexture* PostProcessing::GetDummyTexture()
|
|
{
|
|
if (s_dummy_texture)
|
|
return s_dummy_texture.get();
|
|
|
|
const u32 zero = 0;
|
|
s_dummy_texture = g_gpu_device->FetchTexture(1, 1, 1, 1, 1, GPUTexture::Type::Texture, GPUTexture::Format::RGBA8,
|
|
&zero, sizeof(zero));
|
|
if (!s_dummy_texture)
|
|
Log_ErrorPrint("Failed to create dummy texture.");
|
|
|
|
return s_dummy_texture.get();
|
|
}
|
|
|
|
bool PostProcessing::CheckTargets(GPUTexture::Format target_format, u32 target_width, u32 target_height,
|
|
ProgressCallback* progress)
|
|
{
|
|
if (s_target_format == target_format && s_target_width == target_width && s_target_height == target_height)
|
|
return true;
|
|
|
|
// In case any allocs fail.
|
|
DestroyTextures();
|
|
|
|
if (!(s_input_texture = g_gpu_device->FetchTexture(target_width, target_height, 1, 1, 1,
|
|
GPUTexture::Type::RenderTarget, target_format)) ||
|
|
!(s_output_texture = g_gpu_device->FetchTexture(target_width, target_height, 1, 1, 1,
|
|
GPUTexture::Type::RenderTarget, target_format)))
|
|
{
|
|
DestroyTextures();
|
|
return false;
|
|
}
|
|
|
|
if (!progress)
|
|
progress = ProgressCallback::NullProgressCallback;
|
|
|
|
progress->SetProgressRange(static_cast<u32>(s_stages.size()));
|
|
progress->SetProgressValue(0);
|
|
|
|
for (size_t i = 0; i < s_stages.size(); i++)
|
|
{
|
|
Shader* const shader = s_stages[i].get();
|
|
|
|
progress->SetFormattedStatusText("Compiling %s...", shader->GetName().c_str());
|
|
|
|
if (!shader->CompilePipeline(target_format, target_width, target_height, progress) ||
|
|
!shader->ResizeOutput(target_format, target_width, target_height))
|
|
{
|
|
Log_ErrorPrintf("Failed to compile one or more post-processing shaders, disabling.");
|
|
Host::AddIconOSDMessage(
|
|
"PostProcessLoadFail", ICON_FA_EXCLAMATION_TRIANGLE,
|
|
fmt::format("Failed to compile post-processing shader '{}'. Disabling post-processing.", shader->GetName()));
|
|
s_enabled = false;
|
|
return false;
|
|
}
|
|
|
|
progress->SetProgressValue(static_cast<u32>(i + 1));
|
|
}
|
|
|
|
s_target_format = target_format;
|
|
s_target_width = target_width;
|
|
s_target_height = target_height;
|
|
return true;
|
|
}
|
|
|
|
void PostProcessing::DestroyTextures()
|
|
{
|
|
s_target_format = GPUTexture::Format::Unknown;
|
|
s_target_width = 0;
|
|
s_target_height = 0;
|
|
|
|
g_gpu_device->RecycleTexture(std::move(s_output_texture));
|
|
g_gpu_device->RecycleTexture(std::move(s_input_texture));
|
|
}
|
|
|
|
bool PostProcessing::Apply(GPUTexture* final_target, s32 final_left, s32 final_top, s32 final_width, s32 final_height,
|
|
s32 orig_width, s32 orig_height)
|
|
{
|
|
GL_SCOPE("PostProcessing Apply");
|
|
|
|
GPUTexture* input = s_input_texture.get();
|
|
GPUTexture* output = s_output_texture.get();
|
|
input->MakeReadyForSampling();
|
|
|
|
for (const std::unique_ptr<Shader>& stage : s_stages)
|
|
{
|
|
const bool is_final = (stage.get() == s_stages.back().get());
|
|
|
|
if (!stage->Apply(input, is_final ? final_target : output, final_left, final_top, final_width, final_height,
|
|
orig_width, orig_height, s_target_width, s_target_height))
|
|
{
|
|
return false;
|
|
}
|
|
|
|
if (!is_final)
|
|
{
|
|
output->MakeReadyForSampling();
|
|
std::swap(input, output);
|
|
}
|
|
}
|
|
|
|
return true;
|
|
}
|