From f24b14e7cf84c3028641decaa60cd3a329493c08 Mon Sep 17 00:00:00 2001 From: CamilleLaVey Date: Fri, 4 Sep 2026 03:19:15 -0400 Subject: [PATCH] [vulkan] Initial implementation of post-processing shaders --- cpmfile.json | 5 + dist/post_shaders/EdenColorGrade.fx | 62 ++ dist/post_shaders/EdenSharpen.fx | 45 + dist/post_shaders/EdenVignette.fx | 50 + externals/CMakeLists.txt | 31 + .../settings/model/FxUniformSetting.kt | 103 ++ .../features/settings/model/Settings.kt | 1 + .../features/settings/model/StringSetting.kt | 1 + .../settings/ui/SettingsFragmentPresenter.kt | 218 +++++ .../fragments/GamePropertiesFragment.kt | 14 + .../fragments/HomeSettingsFragment.kt | 14 + .../yuzu_emu/utils/NativePostProcessing.kt | 175 ++++ src/android/app/src/main/jni/CMakeLists.txt | 1 + .../src/main/jni/native_post_processing.cpp | 160 ++++ .../main/res/drawable/ic_post_processing.xml | 10 + .../app/src/main/res/values/strings.xml | 12 + src/common/fs/fs_paths.h | 1 + src/common/fs/path_util.cpp | 1 + src/common/fs/path_util.h | 1 + src/common/settings.h | 8 + src/qt_common/config/shared_translation.cpp | 1 + src/video_core/CMakeLists.txt | 11 + src/video_core/post_processing/fx_chain.cpp | 285 ++++++ src/video_core/post_processing/fx_chain.h | 76 ++ src/video_core/post_processing/fx_compile.cpp | 105 ++ src/video_core/post_processing/fx_compile.h | 29 + src/video_core/post_processing/fx_effect.cpp | 283 ++++++ src/video_core/post_processing/fx_effect.h | 75 ++ .../renderer_vulkan/present/layer.cpp | 39 + .../renderer_vulkan/present/layer.h | 5 + .../renderer_vulkan/present/post_process.cpp | 899 ++++++++++++++++++ .../renderer_vulkan/present/post_process.h | 140 +++ .../renderer_vulkan/renderer_vulkan.cpp | 6 + src/yuzu/CMakeLists.txt | 2 + .../configure_post_processing.cpp | 378 ++++++++ .../configuration/configure_post_processing.h | 35 + src/yuzu/main.ui | 6 + src/yuzu/main_window.cpp | 16 + src/yuzu/main_window.h | 3 + 39 files changed, 3307 insertions(+) create mode 100644 dist/post_shaders/EdenColorGrade.fx create mode 100644 dist/post_shaders/EdenSharpen.fx create mode 100644 dist/post_shaders/EdenVignette.fx create mode 100644 src/android/app/src/main/java/org/yuzu/yuzu_emu/features/settings/model/FxUniformSetting.kt create mode 100644 src/android/app/src/main/java/org/yuzu/yuzu_emu/utils/NativePostProcessing.kt create mode 100644 src/android/app/src/main/jni/native_post_processing.cpp create mode 100644 src/android/app/src/main/res/drawable/ic_post_processing.xml create mode 100644 src/video_core/post_processing/fx_chain.cpp create mode 100644 src/video_core/post_processing/fx_chain.h create mode 100644 src/video_core/post_processing/fx_compile.cpp create mode 100644 src/video_core/post_processing/fx_compile.h create mode 100644 src/video_core/post_processing/fx_effect.cpp create mode 100644 src/video_core/post_processing/fx_effect.h create mode 100644 src/video_core/renderer_vulkan/present/post_process.cpp create mode 100644 src/video_core/renderer_vulkan/present/post_process.h create mode 100644 src/yuzu/configuration/configure_post_processing.cpp create mode 100644 src/yuzu/configuration/configure_post_processing.h diff --git a/cpmfile.json b/cpmfile.json index c5ea35c955..f8bb6c564b 100644 --- a/cpmfile.json +++ b/cpmfile.json @@ -246,6 +246,11 @@ "repo": "stachenov/quazip", "version": "2e95c9001b" }, + "reshade": { + "hash": "a1bd3fcf135fb6d018c1831ae45a8942d9777d0418b55e1189921e2ab775d1b53b0a9808924e09ef1c3e68ea11d69b3bcbebc7f4b59de14f6deec2dc24531d5e", + "repo": "crosire/reshade", + "version": "v6.7.3" + }, "sdl3": { "hash": "df5a323af7ac366661a3c0e887969c72584d232f3cc211419d59b0487b620b6b2859d4549c9e8df002ee489290062e466fcfddf7edc0872a37b1f2845e81c0f3", "min_version": "3.2.10", diff --git a/dist/post_shaders/EdenColorGrade.fx b/dist/post_shaders/EdenColorGrade.fx new file mode 100644 index 0000000000..bd80f8d4bb --- /dev/null +++ b/dist/post_shaders/EdenColorGrade.fx @@ -0,0 +1,62 @@ +texture EdenBackBufferTex : COLOR; +sampler EdenBackBuffer { Texture = EdenBackBufferTex; }; + +uniform float Saturation < + ui_type = "slider"; + ui_label = "Saturation"; + ui_min = 0.0; ui_max = 2.0; ui_step = 0.01; +> = 1.0; + +uniform float Brightness < + ui_type = "slider"; + ui_label = "Brightness"; + ui_min = 0.0; ui_max = 2.0; ui_step = 0.01; +> = 1.0; + +uniform float Contrast < + ui_type = "slider"; + ui_label = "Contrast"; + ui_min = 0.0; ui_max = 2.0; ui_step = 0.01; +> = 1.0; + +uniform float Gamma < + ui_type = "slider"; + ui_label = "Gamma"; + ui_min = 0.5; ui_max = 2.0; ui_step = 0.01; +> = 1.0; + +void VS_Eden(in uint id : SV_VertexID, out float4 pos : SV_Position, out float2 uv : TEXCOORD) +{ + uv = float2(0.0, 0.0); + if (id == 2) + { + uv.x = 2.0; + } + if (id == 1) + { + uv.y = 2.0; + } + pos = float4(uv * float2(2.0, -2.0) + float2(-1.0, 1.0), 0.0, 1.0); +} + +float4 PS_ColorGrade(float4 pos : SV_Position, float2 uv : TEXCOORD) : SV_Target +{ + float3 rgb = tex2D(EdenBackBuffer, uv).rgb; + + float luma = dot(rgb, float3(0.2126, 0.7152, 0.0722)); + rgb = lerp(float3(luma, luma, luma), rgb, Saturation); + rgb *= Brightness; + rgb = (rgb - 0.5) * Contrast + 0.5; + rgb = pow(max(rgb, 0.0), 1.0 / max(Gamma, 0.0001)); + + return float4(saturate(rgb), 1.0); +} + +technique EdenColorGrade +{ + pass + { + VertexShader = VS_Eden; + PixelShader = PS_ColorGrade; + } +} diff --git a/dist/post_shaders/EdenSharpen.fx b/dist/post_shaders/EdenSharpen.fx new file mode 100644 index 0000000000..323d764719 --- /dev/null +++ b/dist/post_shaders/EdenSharpen.fx @@ -0,0 +1,45 @@ +texture EdenBackBufferTex : COLOR; +sampler EdenBackBuffer { Texture = EdenBackBufferTex; }; + +uniform float Amount < + ui_type = "slider"; + ui_label = "Amount"; + ui_min = 0.0; ui_max = 3.0; ui_step = 0.01; +> = 0.6; + +void VS_Eden(in uint id : SV_VertexID, out float4 pos : SV_Position, out float2 uv : TEXCOORD) +{ + uv = float2(0.0, 0.0); + if (id == 2) + { + uv.x = 2.0; + } + if (id == 1) + { + uv.y = 2.0; + } + pos = float4(uv * float2(2.0, -2.0) + float2(-1.0, 1.0), 0.0, 1.0); +} + +float4 PS_Sharpen(float4 pos : SV_Position, float2 uv : TEXCOORD) : SV_Target +{ + float2 texel = float2(BUFFER_RCP_WIDTH, BUFFER_RCP_HEIGHT); + + float3 centre = tex2D(EdenBackBuffer, uv).rgb; + float3 blur = tex2D(EdenBackBuffer, uv + float2(-texel.x, 0.0)).rgb; + blur += tex2D(EdenBackBuffer, uv + float2(texel.x, 0.0)).rgb; + blur += tex2D(EdenBackBuffer, uv + float2(0.0, -texel.y)).rgb; + blur += tex2D(EdenBackBuffer, uv + float2(0.0, texel.y)).rgb; + blur *= 0.25; + + return float4(centre + (centre - blur) * Amount, 1.0); +} + +technique EdenSharpen +{ + pass + { + VertexShader = VS_Eden; + PixelShader = PS_Sharpen; + } +} diff --git a/dist/post_shaders/EdenVignette.fx b/dist/post_shaders/EdenVignette.fx new file mode 100644 index 0000000000..032a7699ef --- /dev/null +++ b/dist/post_shaders/EdenVignette.fx @@ -0,0 +1,50 @@ +texture EdenBackBufferTex : COLOR; +sampler EdenBackBuffer { Texture = EdenBackBufferTex; }; + +uniform float Strength < + ui_type = "slider"; + ui_label = "Strength"; + ui_tooltip = "How dark the corners become."; + ui_min = 0.0; ui_max = 2.0; ui_step = 0.01; +> = 0.6; + +uniform float Aspect < + ui_type = "slider"; + ui_label = "Aspect"; + ui_min = 0.5; ui_max = 2.0; ui_step = 0.01; +> = 1.0; + +void VS_Eden(in uint id : SV_VertexID, out float4 pos : SV_Position, out float2 uv : TEXCOORD) +{ + uv = float2(0.0, 0.0); + if (id == 2) + { + uv.x = 2.0; + } + if (id == 1) + { + uv.y = 2.0; + } + pos = float4(uv * float2(2.0, -2.0) + float2(-1.0, 1.0), 0.0, 1.0); +} + +float4 PS_Vignette(float4 pos : SV_Position, float2 uv : TEXCOORD) : SV_Target +{ + float2 diff = uv - 0.5; + diff.x *= Aspect; + diff.y /= max(Aspect, 0.0001); + + float falloff = 1.0 - min(1.0, Strength * dot(diff, diff) * 2.0); + float3 rgb = tex2D(EdenBackBuffer, uv).rgb; + + return float4(rgb * falloff, 1.0); +} + +technique EdenVignette +{ + pass + { + VertexShader = VS_Eden; + PixelShader = PS_Vignette; + } +} diff --git a/externals/CMakeLists.txt b/externals/CMakeLists.txt index 0682f643e2..1c16db723a 100644 --- a/externals/CMakeLists.txt +++ b/externals/CMakeLists.txt @@ -195,6 +195,37 @@ else() endif() endif() +# reshadefx +AddJsonPackage(reshade DOWNLOAD_ONLY) + +set(RESHADEFX_SHIM_DIR ${CMAKE_CURRENT_BINARY_DIR}/reshadefx_shim) +file(WRITE ${RESHADEFX_SHIM_DIR}/spirv.hpp "#include \n") +file(WRITE ${RESHADEFX_SHIM_DIR}/GLSL.std.450.h "#include \n") + +add_library(reshadefx STATIC + ${reshade_SOURCE_DIR}/source/effect_codegen_spirv.cpp + ${reshade_SOURCE_DIR}/source/effect_expression.cpp + ${reshade_SOURCE_DIR}/source/effect_lexer.cpp + ${reshade_SOURCE_DIR}/source/effect_parser_exp.cpp + ${reshade_SOURCE_DIR}/source/effect_parser_stmt.cpp + ${reshade_SOURCE_DIR}/source/effect_preprocessor.cpp + ${reshade_SOURCE_DIR}/source/effect_symbol_table.cpp +) + +target_include_directories(reshadefx PUBLIC ${reshade_SOURCE_DIR}/source) +target_include_directories(reshadefx PRIVATE ${RESHADEFX_SHIM_DIR}) +target_link_libraries(reshadefx PUBLIC SPIRV-Headers::SPIRV-Headers) + +if (NOT MSVC) + target_compile_options(reshadefx PRIVATE -w) +else() + target_compile_options(reshadefx PRIVATE /w) +endif() + +if (NOT TARGET reshadefx::reshadefx) + add_library(reshadefx::reshadefx ALIAS reshadefx) +endif() + # Catch2 if (YUZU_TESTS OR DYNARMIC_TESTS) AddJsonPackage(catch2) diff --git a/src/android/app/src/main/java/org/yuzu/yuzu_emu/features/settings/model/FxUniformSetting.kt b/src/android/app/src/main/java/org/yuzu/yuzu_emu/features/settings/model/FxUniformSetting.kt new file mode 100644 index 0000000000..033e92c357 --- /dev/null +++ b/src/android/app/src/main/java/org/yuzu/yuzu_emu/features/settings/model/FxUniformSetting.kt @@ -0,0 +1,103 @@ +// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project +// SPDX-License-Identifier: GPL-3.0-or-later + +package org.yuzu.yuzu_emu.features.settings.model + +import org.yuzu.yuzu_emu.utils.NativePostProcessing +import kotlin.math.roundToInt + +abstract class FxUniformSetting( + protected val index: Int, + protected val uniform: NativePostProcessing.Uniform, + protected val component: Int +) : AbstractSetting { + override val key: String + get() = "fx_${index}_${uniform.name}_$component" + + override val isRuntimeModifiable: Boolean + get() = true + + override val pairedSettingKey: String + get() = "" + + override val isSwitchable: Boolean + get() = false + + override val isSaveable: Boolean + get() = true + + override var global: Boolean + get() = true + set(_) {} + + protected fun currentValue(): Float { + if (NativePostProcessing.hasValue(index, uniform.name)) { + return NativePostProcessing.getValue(index, uniform.name, component) + } + return uniform.defaultAt(component) + } + + protected fun commit(value: Float) { + NativePostProcessing.setValue(index, uniform.name, component, value) + NativePostProcessing.store() + } + + override fun reset() = commit(uniform.defaultAt(component)) +} + +class FxUniformSliderSetting( + index: Int, + uniform: NativePostProcessing.Uniform, + component: Int +) : FxUniformSetting(index, uniform, component), AbstractIntSetting { + override val defaultValue: Any + get() = ((uniform.defaultAt(component) - uniform.min) / uniform.step).roundToInt() + + override fun getInt(needsGlobal: Boolean): Int = + ((currentValue() - uniform.min) / uniform.step).roundToInt() + + override fun setInt(value: Int) = commit(uniform.min + value * uniform.step) + + override fun getValueAsString(needsGlobal: Boolean): String { + if (uniform.kind == NativePostProcessing.KIND_FLOAT) { + return String.format("%.3f", currentValue()) + } + return currentValue().roundToInt().toString() + } +} + +class FxUniformChoiceSetting( + index: Int, + uniform: NativePostProcessing.Uniform, + component: Int +) : FxUniformSetting(index, uniform, component), AbstractIntSetting { + override val defaultValue: Any + get() = uniform.defaultAt(component).roundToInt() + + override fun getInt(needsGlobal: Boolean): Int = currentValue().roundToInt() + + override fun setInt(value: Int) = commit(value.toFloat()) + + override fun getValueAsString(needsGlobal: Boolean): String = getInt().toString() +} + +class FxUniformBooleanSetting( + index: Int, + uniform: NativePostProcessing.Uniform, + component: Int +) : FxUniformSetting(index, uniform, component), AbstractBooleanSetting { + override val defaultValue: Any + get() = uniform.defaultAt(component) != 0f + + override fun getBoolean(needsGlobal: Boolean): Boolean = currentValue() != 0f + + override fun setBoolean(value: Boolean) { + if (value) { + commit(1f) + return + } + commit(0f) + } + + override fun getValueAsString(needsGlobal: Boolean): String = getBoolean().toString() +} diff --git a/src/android/app/src/main/java/org/yuzu/yuzu_emu/features/settings/model/Settings.kt b/src/android/app/src/main/java/org/yuzu/yuzu_emu/features/settings/model/Settings.kt index fc4df4952d..23c5ceb88b 100644 --- a/src/android/app/src/main/java/org/yuzu/yuzu_emu/features/settings/model/Settings.kt +++ b/src/android/app/src/main/java/org/yuzu/yuzu_emu/features/settings/model/Settings.kt @@ -12,6 +12,7 @@ object Settings { SECTION_SYSTEM(R.string.preferences_system), SECTION_RENDERER(R.string.preferences_graphics), SECTION_FRAME_GEN(R.string.frame_gen), + SECTION_POST_PROCESSING(R.string.post_processing), SECTION_PERFORMANCE_STATS(R.string.stats_overlay_options), SECTION_INPUT_OVERLAY(R.string.input_overlay_options), SECTION_SOC_OVERLAY(R.string.soc_overlay_options), diff --git a/src/android/app/src/main/java/org/yuzu/yuzu_emu/features/settings/model/StringSetting.kt b/src/android/app/src/main/java/org/yuzu/yuzu_emu/features/settings/model/StringSetting.kt index 43fb1fe0fe..e3ccf9e998 100644 --- a/src/android/app/src/main/java/org/yuzu/yuzu_emu/features/settings/model/StringSetting.kt +++ b/src/android/app/src/main/java/org/yuzu/yuzu_emu/features/settings/model/StringSetting.kt @@ -13,6 +13,7 @@ enum class StringSetting(override val key: String) : AbstractStringSetting { DEVICE_NAME("device_name"), LOG_FILTER("log_filter"), PROGRAM_ARGS("program_args"), + POST_SHADER_CHAIN("post_shader_chain"), WEB_TOKEN("eden_token"), WEB_USERNAME("eden_username") diff --git a/src/android/app/src/main/java/org/yuzu/yuzu_emu/features/settings/ui/SettingsFragmentPresenter.kt b/src/android/app/src/main/java/org/yuzu/yuzu_emu/features/settings/ui/SettingsFragmentPresenter.kt index 2b5b966021..e6849331ea 100644 --- a/src/android/app/src/main/java/org/yuzu/yuzu_emu/features/settings/ui/SettingsFragmentPresenter.kt +++ b/src/android/app/src/main/java/org/yuzu/yuzu_emu/features/settings/ui/SettingsFragmentPresenter.kt @@ -18,6 +18,9 @@ import org.yuzu.yuzu_emu.features.input.model.NpadStyleIndex import org.yuzu.yuzu_emu.features.settings.model.AbstractBooleanSetting import org.yuzu.yuzu_emu.features.settings.model.AbstractIntSetting import org.yuzu.yuzu_emu.features.settings.model.BooleanSetting +import org.yuzu.yuzu_emu.features.settings.model.FxUniformBooleanSetting +import org.yuzu.yuzu_emu.features.settings.model.FxUniformChoiceSetting +import org.yuzu.yuzu_emu.features.settings.model.FxUniformSliderSetting import org.yuzu.yuzu_emu.features.settings.model.ByteSetting import org.yuzu.yuzu_emu.features.settings.model.IntSetting import org.yuzu.yuzu_emu.features.settings.model.LongSetting @@ -30,6 +33,7 @@ import org.yuzu.yuzu_emu.features.settings.model.view.* import org.yuzu.yuzu_emu.utils.InputHandler import org.yuzu.yuzu_emu.utils.LosslessScalingHelper import org.yuzu.yuzu_emu.utils.NativeConfig +import org.yuzu.yuzu_emu.utils.NativePostProcessing import org.yuzu.yuzu_emu.utils.DirectoryInitialization import org.yuzu.yuzu_emu.utils.FullscreenHelper import androidx.core.content.edit @@ -163,6 +167,7 @@ class SettingsFragmentPresenter( MenuTag.SECTION_SYSTEM -> addSystemSettings(sl) MenuTag.SECTION_RENDERER -> addGraphicsSettings(sl) MenuTag.SECTION_FRAME_GEN -> addFrameGenSettings(sl) + MenuTag.SECTION_POST_PROCESSING -> addPostProcessingSettings(sl) MenuTag.SECTION_PERFORMANCE_STATS -> addPerformanceOverlaySettings(sl) MenuTag.SECTION_SOC_OVERLAY -> addSocOverlaySettings(sl) MenuTag.SECTION_INPUT_OVERLAY -> addInputOverlaySettings(sl) @@ -190,6 +195,219 @@ class SettingsFragmentPresenter( } } + private fun addPostProcessingSettings(sl: ArrayList) { + val usable = NativePostProcessing.catalog().filter { it.valid } + + sl.apply { + add( + RunnableSetting( + titleId = R.string.post_processing_reload, + descriptionId = R.string.post_processing_reload_description, + isRunnable = true + ) { + NativePostProcessing.reload() + settingsViewModel.setReloadListAndNotifyDataset(true) + } + ) + + if (usable.isEmpty()) { + add( + RunnableSetting( + titleId = R.string.post_processing_empty, + descriptionString = NativePostProcessing.getShaderDirectory(), + isRunnable = false + ) {} + ) + return@apply + } + + val labels = mutableListOf() + val files = mutableListOf() + val techniques = mutableListOf() + for (effect in usable) { + for (technique in effect.techniques) { + if (effect.techniques.size == 1) { + labels.add(effect.name) + } else { + labels.add(effect.name + " \u00b7 " + technique) + } + files.add(effect.file) + techniques.add(technique) + } + } + + val chain = NativePostProcessing.chain() + for (index in chain.indices) { + val entry = chain[index] + val effect = usable.firstOrNull { it.file == entry.file } + + var header = entry.file + if (effect != null) { + header = effect.name + } + add(HeaderSetting(titleString = header)) + + add( + IntSingleChoiceSetting( + buildSlotSelector(index, entry, files, techniques), + titleId = R.string.post_processing_effect, + choices = labels.toTypedArray(), + values = labels.indices.toList().toTypedArray() + ) + ) + + if (effect != null) { + for (uniform in effect.uniforms) { + addUniform(this, index, uniform) + } + } + + if (index > 0) { + add( + RunnableSetting( + titleId = R.string.post_processing_move_up, + isRunnable = true + ) { + NativePostProcessing.move(index, -1) + NativePostProcessing.store() + settingsViewModel.setReloadListAndNotifyDataset(true) + } + ) + } + if (index < chain.size - 1) { + add( + RunnableSetting( + titleId = R.string.post_processing_move_down, + isRunnable = true + ) { + NativePostProcessing.move(index, 1) + NativePostProcessing.store() + settingsViewModel.setReloadListAndNotifyDataset(true) + } + ) + } + add( + RunnableSetting( + titleId = R.string.post_processing_reset, + isRunnable = true + ) { + NativePostProcessing.resetValues(index) + NativePostProcessing.store() + settingsViewModel.setReloadListAndNotifyDataset(true) + } + ) + add( + RunnableSetting( + titleId = R.string.post_processing_remove, + isRunnable = true + ) { + NativePostProcessing.remove(index) + NativePostProcessing.store() + settingsViewModel.setReloadListAndNotifyDataset(true) + } + ) + } + + add( + RunnableSetting( + titleId = R.string.post_processing_add, + isRunnable = true + ) { + NativePostProcessing.append(files[0], techniques[0]) + NativePostProcessing.store() + settingsViewModel.setReloadListAndNotifyDataset(true) + } + ) + } + } + + private fun buildSlotSelector( + index: Int, + entry: NativePostProcessing.ChainEntry, + files: List, + techniques: List + ): AbstractIntSetting = object : AbstractIntSetting { + override val key = "fx_slot_$index" + + override fun getInt(needsGlobal: Boolean): Int { + for (i in files.indices) { + if (files[i] == entry.file && techniques[i] == entry.technique) { + return i + } + } + return -1 + } + + override fun setInt(value: Int) { + NativePostProcessing.replace(index, files[value], techniques[value]) + NativePostProcessing.store() + settingsViewModel.setReloadListAndNotifyDataset(true) + } + + override val defaultValue = 0 + override fun getValueAsString(needsGlobal: Boolean): String = getInt().toString() + override fun reset() {} + override val isRuntimeModifiable = true + override val pairedSettingKey = "" + override val isSwitchable = false + override val isSaveable = true + override var global: Boolean + get() = true + set(_) {} + } + + private fun addUniform( + sl: ArrayList, + index: Int, + uniform: NativePostProcessing.Uniform + ) { + if (uniform.uiType == NativePostProcessing.UI_CHECKBOX || + uniform.kind == NativePostProcessing.KIND_BOOL + ) { + sl.add( + SwitchSetting( + FxUniformBooleanSetting(index, uniform, 0), + titleString = uniform.label, + descriptionString = uniform.tooltip + ) + ) + return + } + + if (uniform.items.isNotEmpty() && + (uniform.uiType == NativePostProcessing.UI_COMBO || + uniform.uiType == NativePostProcessing.UI_RADIO) + ) { + sl.add( + IntSingleChoiceSetting( + FxUniformChoiceSetting(index, uniform, 0), + titleString = uniform.label, + descriptionString = uniform.tooltip, + choices = uniform.items.toTypedArray(), + values = uniform.items.indices.toList().toTypedArray() + ) + ) + return + } + + for (component in 0 until uniform.components) { + var title = uniform.label + if (uniform.components > 1) { + title = uniform.label + " [" + component + "]" + } + sl.add( + SliderSetting( + FxUniformSliderSetting(index, uniform, component), + titleString = title, + descriptionString = uniform.tooltip, + min = 0, + max = uniform.steps + ) + ) + } + } + + private fun addConfigSettings(sl: ArrayList) { sl.apply { add( diff --git a/src/android/app/src/main/java/org/yuzu/yuzu_emu/fragments/GamePropertiesFragment.kt b/src/android/app/src/main/java/org/yuzu/yuzu_emu/fragments/GamePropertiesFragment.kt index a2d6563e50..d2505c5f61 100644 --- a/src/android/app/src/main/java/org/yuzu/yuzu_emu/fragments/GamePropertiesFragment.kt +++ b/src/android/app/src/main/java/org/yuzu/yuzu_emu/fragments/GamePropertiesFragment.kt @@ -383,6 +383,20 @@ class GamePropertiesFragment : Fragment() { } ) ) + add( + SubmenuProperty( + R.string.post_processing, + R.string.post_processing_per_game_description, + R.drawable.ic_post_processing, + action = { + val action = HomeNavigationDirections.actionGlobalSettingsActivity( + args.game, + Settings.MenuTag.SECTION_POST_PROCESSING + ) + binding.root.findNavController().navigate(action) + } + ) + ) if (GpuDriverHelper.isAdrenoGpu()) { add( diff --git a/src/android/app/src/main/java/org/yuzu/yuzu_emu/fragments/HomeSettingsFragment.kt b/src/android/app/src/main/java/org/yuzu/yuzu_emu/fragments/HomeSettingsFragment.kt index bd4d8465f3..2b4cfc5ca8 100644 --- a/src/android/app/src/main/java/org/yuzu/yuzu_emu/fragments/HomeSettingsFragment.kt +++ b/src/android/app/src/main/java/org/yuzu/yuzu_emu/fragments/HomeSettingsFragment.kt @@ -171,6 +171,20 @@ class HomeSettingsFragment : Fragment() { ) ) } + add( + HomeSetting( + R.string.post_processing, + R.string.post_processing_description, + R.drawable.ic_post_processing, + { + val action = HomeNavigationDirections.actionGlobalSettingsActivity( + null, + Settings.MenuTag.SECTION_POST_PROCESSING + ) + binding.root.findNavController().navigate(action) + } + ) + ) add( HomeSetting( R.string.lossless_scaling, diff --git a/src/android/app/src/main/java/org/yuzu/yuzu_emu/utils/NativePostProcessing.kt b/src/android/app/src/main/java/org/yuzu/yuzu_emu/utils/NativePostProcessing.kt new file mode 100644 index 0000000000..7129d617f5 --- /dev/null +++ b/src/android/app/src/main/java/org/yuzu/yuzu_emu/utils/NativePostProcessing.kt @@ -0,0 +1,175 @@ +// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project +// SPDX-License-Identifier: GPL-3.0-or-later + +package org.yuzu.yuzu_emu.utils + +import org.json.JSONArray +import org.json.JSONObject + +object NativePostProcessing { + const val KIND_BOOL = 0 + const val KIND_INT = 1 + const val KIND_FLOAT = 2 + + const val UI_HIDDEN = 0 + const val UI_SLIDER = 1 + const val UI_DRAG = 2 + const val UI_COMBO = 3 + const val UI_RADIO = 4 + const val UI_CHECKBOX = 5 + const val UI_COLOR = 6 + const val UI_INPUT_BOX = 7 + + external fun getCatalogJson(): String + + external fun getChainJson(): String + + external fun append(file: String, technique: String) + + external fun replace(index: Int, file: String, technique: String) + + external fun remove(index: Int) + + external fun move(index: Int, delta: Int) + + external fun resetValues(index: Int) + + external fun getValue(index: Int, uniform: String, component: Int): Float + + external fun hasValue(index: Int, uniform: String): Boolean + + external fun setValue(index: Int, uniform: String, component: Int, value: Float) + + external fun store() + + external fun reload() + + external fun getShaderDirectory(): String + + data class Uniform( + val name: String, + val label: String, + val tooltip: String, + val category: String, + val kind: Int, + val uiType: Int, + val components: Int, + val min: Float, + val max: Float, + val step: Float, + val items: List, + val defaults: List + ) { + val steps: Int + get() { + val span = max - min + if (step <= 0f) { + return 1 + } + val count = Math.round(span / step) + if (count < 1) { + return 1 + } + return count + } + + fun defaultAt(component: Int): Float { + if (component < defaults.size) { + return defaults[component] + } + return 0f + } + } + + data class Effect( + val file: String, + val name: String, + val error: String, + val techniques: List, + val uniforms: List + ) { + val valid: Boolean + get() = error.isEmpty() && techniques.isNotEmpty() + } + + data class ChainEntry(val file: String, val technique: String) + + fun catalog(): List { + val out = mutableListOf() + val array = JSONArray(getCatalogJson()) + for (i in 0 until array.length()) { + val obj = array.getJSONObject(i) + out.add( + Effect( + file = obj.optString("file"), + name = obj.optString("name"), + error = obj.optString("error"), + techniques = obj.optJSONArray("techniques").toStringList(), + uniforms = obj.optJSONArray("uniforms").toUniformList() + ) + ) + } + return out + } + + fun chain(): List { + val out = mutableListOf() + val array = JSONArray(getChainJson()) + for (i in 0 until array.length()) { + val obj = array.getJSONObject(i) + out.add(ChainEntry(obj.optString("file"), obj.optString("technique"))) + } + return out + } + + fun findEffect(file: String): Effect? = catalog().firstOrNull { it.file == file } + + private fun JSONArray?.toStringList(): List { + if (this == null) { + return emptyList() + } + val out = mutableListOf() + for (i in 0 until length()) { + out.add(optString(i)) + } + return out + } + + private fun JSONArray?.toFloatList(): List { + if (this == null) { + return emptyList() + } + val out = mutableListOf() + for (i in 0 until length()) { + out.add(optDouble(i, 0.0).toFloat()) + } + return out + } + + private fun JSONArray?.toUniformList(): List { + if (this == null) { + return emptyList() + } + val out = mutableListOf() + for (i in 0 until length()) { + val obj: JSONObject = optJSONObject(i) ?: continue + out.add( + Uniform( + name = obj.optString("name"), + label = obj.optString("label"), + tooltip = obj.optString("tooltip"), + category = obj.optString("category"), + kind = obj.optInt("kind", KIND_FLOAT), + uiType = obj.optInt("uiType", UI_HIDDEN), + components = obj.optInt("components", 1), + min = obj.optDouble("min", 0.0).toFloat(), + max = obj.optDouble("max", 1.0).toFloat(), + step = obj.optDouble("step", 0.01).toFloat(), + items = obj.optJSONArray("items").toStringList(), + defaults = obj.optJSONArray("defaults").toFloatList() + ) + ) + } + return out + } +} diff --git a/src/android/app/src/main/jni/CMakeLists.txt b/src/android/app/src/main/jni/CMakeLists.txt index 86c05d7c0d..337d9fea1b 100644 --- a/src/android/app/src/main/jni/CMakeLists.txt +++ b/src/android/app/src/main/jni/CMakeLists.txt @@ -17,6 +17,7 @@ add_library(yuzu-android SHARED android_config.cpp android_config.h native_input.cpp + native_post_processing.cpp ) set_property(TARGET yuzu-android PROPERTY IMPORTED_LOCATION ${FFmpeg_LIBRARY_DIR}) diff --git a/src/android/app/src/main/jni/native_post_processing.cpp b/src/android/app/src/main/jni/native_post_processing.cpp new file mode 100644 index 0000000000..c20c039a43 --- /dev/null +++ b/src/android/app/src/main/jni/native_post_processing.cpp @@ -0,0 +1,160 @@ +// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project +// SPDX-License-Identifier: GPL-3.0-or-later + +#include + +#include +#include + +#include "common/android/android_common.h" +#include "video_core/post_processing/fx_chain.h" +#include "video_core/post_processing/fx_effect.h" + +namespace { + +nlohmann::json SerializeUniform(const VideoCore::FxUniformDesc& uniform) { + nlohmann::json out; + out["name"] = uniform.name; + out["label"] = uniform.label; + out["tooltip"] = uniform.tooltip; + out["category"] = uniform.category; + out["kind"] = static_cast(uniform.kind); + out["uiType"] = static_cast(uniform.ui_type); + out["components"] = uniform.components; + out["min"] = uniform.ui_min; + out["max"] = uniform.ui_max; + out["step"] = uniform.ui_step; + out["items"] = uniform.items; + + nlohmann::json defaults = nlohmann::json::array(); + for (u32 i = 0; i < uniform.components; ++i) { + defaults.push_back(uniform.default_value[i]); + } + out["defaults"] = defaults; + + return out; +} + +} // Anonymous namespace + +extern "C" { + +jstring Java_org_yuzu_yuzu_1emu_utils_NativePostProcessing_getCatalogJson(JNIEnv* env, + jobject obj) { + nlohmann::json out = nlohmann::json::array(); + + for (const auto& effect : VideoCore::GetFxCatalog()) { + nlohmann::json entry; + entry["file"] = effect.file; + entry["name"] = effect.name; + entry["error"] = effect.error; + entry["techniques"] = effect.techniques; + + nlohmann::json uniforms = nlohmann::json::array(); + for (const auto& uniform : effect.uniforms) { + uniforms.push_back(SerializeUniform(uniform)); + } + entry["uniforms"] = uniforms; + + out.push_back(entry); + } + + return Common::Android::ToJString(env, out.dump()); +} + +jstring Java_org_yuzu_yuzu_1emu_utils_NativePostProcessing_getChainJson(JNIEnv* env, jobject obj) { + nlohmann::json out = nlohmann::json::array(); + + for (const auto& entry : VideoCore::FxChain::Instance().Entries()) { + nlohmann::json item; + item["file"] = entry.file; + item["technique"] = entry.technique; + + nlohmann::json values = nlohmann::json::object(); + for (const auto& [name, value] : entry.values) { + values[name] = {value[0], value[1], value[2], value[3]}; + } + item["values"] = values; + + out.push_back(item); + } + + return Common::Android::ToJString(env, out.dump()); +} + +void Java_org_yuzu_yuzu_1emu_utils_NativePostProcessing_append(JNIEnv* env, jobject obj, + jstring jfile, jstring jtechnique) { + VideoCore::FxChain::Instance().Append(Common::Android::GetJString(env, jfile), + Common::Android::GetJString(env, jtechnique)); +} + +void Java_org_yuzu_yuzu_1emu_utils_NativePostProcessing_replace(JNIEnv* env, jobject obj, + jint index, jstring jfile, + jstring jtechnique) { + VideoCore::FxChain::Instance().Replace(static_cast(index), + Common::Android::GetJString(env, jfile), + Common::Android::GetJString(env, jtechnique)); +} + +void Java_org_yuzu_yuzu_1emu_utils_NativePostProcessing_remove(JNIEnv* env, jobject obj, + jint index) { + VideoCore::FxChain::Instance().Remove(static_cast(index)); +} + +void Java_org_yuzu_yuzu_1emu_utils_NativePostProcessing_move(JNIEnv* env, jobject obj, jint index, + jint delta) { + VideoCore::FxChain::Instance().Move(static_cast(index), delta); +} + +void Java_org_yuzu_yuzu_1emu_utils_NativePostProcessing_resetValues(JNIEnv* env, jobject obj, + jint index) { + VideoCore::FxChain::Instance().ResetValues(static_cast(index)); +} + +jfloat Java_org_yuzu_yuzu_1emu_utils_NativePostProcessing_getValue(JNIEnv* env, jobject obj, + jint index, jstring juniform, + jint component) { + if (component < 0 || component >= 4) { + return 0.0f; + } + const auto value = VideoCore::FxChain::Instance().GetValue( + static_cast(index), Common::Android::GetJString(env, juniform)); + return value[static_cast(component)]; +} + +jboolean Java_org_yuzu_yuzu_1emu_utils_NativePostProcessing_hasValue(JNIEnv* env, jobject obj, + jint index, + jstring juniform) { + return static_cast(VideoCore::FxChain::Instance().HasValue( + static_cast(index), Common::Android::GetJString(env, juniform))); +} + +void Java_org_yuzu_yuzu_1emu_utils_NativePostProcessing_setValue(JNIEnv* env, jobject obj, + jint index, jstring juniform, + jint component, jfloat value) { + if (component < 0 || component >= 4) { + return; + } + const std::string uniform = Common::Android::GetJString(env, juniform); + auto& chain = VideoCore::FxChain::Instance(); + + auto current = chain.GetValue(static_cast(index), uniform); + current[static_cast(component)] = value; + chain.SetValue(static_cast(index), uniform, current); +} + +void Java_org_yuzu_yuzu_1emu_utils_NativePostProcessing_store(JNIEnv* env, jobject obj) { + VideoCore::FxChain::Instance().StoreToSettings(); +} + +void Java_org_yuzu_yuzu_1emu_utils_NativePostProcessing_reload(JNIEnv* env, jobject obj) { + VideoCore::ReloadFxCatalog(); + VideoCore::FxChain::Instance().DropUnknownEntries(); +} + +jstring Java_org_yuzu_yuzu_1emu_utils_NativePostProcessing_getShaderDirectory(JNIEnv* env, + jobject obj) { + return Common::Android::ToJString(env, VideoCore::GetFxRootDirectory().string()); +} + +} // extern "C" diff --git a/src/android/app/src/main/res/drawable/ic_post_processing.xml b/src/android/app/src/main/res/drawable/ic_post_processing.xml new file mode 100644 index 0000000000..06ce58d40e --- /dev/null +++ b/src/android/app/src/main/res/drawable/ic_post_processing.xml @@ -0,0 +1,10 @@ + + + diff --git a/src/android/app/src/main/res/values/strings.xml b/src/android/app/src/main/res/values/strings.xml index 55783f6e43..9ae24285bd 100644 --- a/src/android/app/src/main/res/values/strings.xml +++ b/src/android/app/src/main/res/values/strings.xml @@ -298,6 +298,18 @@ GPU driver fetcher GPU driver manager Install alternative drivers for potentially better performance or accuracy + Post-Processing Effects + ReShade FX effects applied after rendering + Configure the effect chain for this game + Effect + Add effect + Remove + Move up + Move down + Reset to defaults + Reload from disk + Rescan the shader folder for .fx files + No effects found. Place .fx files in this folder: Frame generation Configure frame generation for this game Insert interpolated frames between rendered ones using Lossless Scaling. Forces FIFO presentation while enabled. diff --git a/src/common/fs/fs_paths.h b/src/common/fs/fs_paths.h index a31e609bda..e4b4e3223c 100644 --- a/src/common/fs/fs_paths.h +++ b/src/common/fs/fs_paths.h @@ -23,6 +23,7 @@ #define LOSSLESS_DIR "lossless" #define NAND_DIR "nand" #define PLAY_TIME_DIR "play_time" +#define POST_SHADER_DIR "post_shaders" #define SCREENSHOTS_DIR "screenshots" #define SDMC_DIR "sdmc" #define SHADER_DIR "shader" diff --git a/src/common/fs/path_util.cpp b/src/common/fs/path_util.cpp index b4c7eae343..02cc799d84 100644 --- a/src/common/fs/path_util.cpp +++ b/src/common/fs/path_util.cpp @@ -160,6 +160,7 @@ public: GenerateEdenPath(EdenPath::LosslessDir, eden_path / LOSSLESS_DIR); GenerateEdenPath(EdenPath::NANDDir, eden_path / NAND_DIR); GenerateEdenPath(EdenPath::PlayTimeDir, eden_path / PLAY_TIME_DIR); + GenerateEdenPath(EdenPath::PostShaderDir, eden_path / POST_SHADER_DIR); GenerateEdenPath(EdenPath::SaveDir, eden_path / NAND_DIR); GenerateEdenPath(EdenPath::ScreenshotsDir, eden_path / SCREENSHOTS_DIR); GenerateEdenPath(EdenPath::SDMCDir, eden_path / SDMC_DIR); diff --git a/src/common/fs/path_util.h b/src/common/fs/path_util.h index febed9c388..b99828f738 100644 --- a/src/common/fs/path_util.h +++ b/src/common/fs/path_util.h @@ -26,6 +26,7 @@ enum class EdenPath { LosslessDir, // Where the user-supplied Lossless Scaling library is stored. NANDDir, // Where the emulated NAND is stored. PlayTimeDir, // Where play time data is stored. + PostShaderDir, // Where user post-processing shaders are stored. SaveDir, // Where save data is stored. ScreenshotsDir, // Where yuzu screenshots are stored. SDMCDir, // Where the emulated SDMC is stored. diff --git a/src/common/settings.h b/src/common/settings.h index 60cf874306..49ef60f3cc 100644 --- a/src/common/settings.h +++ b/src/common/settings.h @@ -388,6 +388,14 @@ struct Values { true, true}; + SwitchableSetting post_shader_chain{linkage, + std::string(), + "post_shader_chain", + Category::Renderer, + Specialization::Default, + true, + true}; + SwitchableSetting frame_gen{linkage, false, "frame_gen", Category::Renderer, Specialization::Default, true, false}; diff --git a/src/qt_common/config/shared_translation.cpp b/src/qt_common/config/shared_translation.cpp index 7fd55ce038..be2f986eaf 100644 --- a/src/qt_common/config/shared_translation.cpp +++ b/src/qt_common/config/shared_translation.cpp @@ -150,6 +150,7 @@ std::unique_ptr InitializeTranslations(QObject* parent) { INSERT(Settings, anti_aliasing, tr("Anti-Aliasing Method:"), tr("The anti-aliasing method to use.\nSMAA offers the best quality.\nFXAA " "can produce a more stable picture in lower resolutions.")); + INSERT(Settings, post_shader_chain, QString(), QString()); INSERT(Settings, fullscreen_mode, tr("Fullscreen Mode:"), tr("The method used to render the window in fullscreen.\nBorderless offers the best " "compatibility with the on-screen keyboard that some games request for " diff --git a/src/video_core/CMakeLists.txt b/src/video_core/CMakeLists.txt index c86849837b..c284e07a24 100644 --- a/src/video_core/CMakeLists.txt +++ b/src/video_core/CMakeLists.txt @@ -117,6 +117,14 @@ add_library(video_core STATIC renderer_null/renderer_null.cpp renderer_null/renderer_null.h + # Post-processing + post_processing/fx_chain.cpp + post_processing/fx_chain.h + post_processing/fx_compile.cpp + post_processing/fx_compile.h + post_processing/fx_effect.cpp + post_processing/fx_effect.h + # Vulkan renderer_vulkan/present/anti_alias_pass.h renderer_vulkan/present/filters.cpp @@ -127,6 +135,8 @@ add_library(video_core STATIC renderer_vulkan/present/fxaa.h renderer_vulkan/present/layer.cpp renderer_vulkan/present/layer.h + renderer_vulkan/present/post_process.cpp + renderer_vulkan/present/post_process.h renderer_vulkan/present/present_push_constants.h renderer_vulkan/present/smaa.cpp renderer_vulkan/present/smaa.h @@ -377,6 +387,7 @@ add_dependencies(video_core host_shaders) target_include_directories(video_core PRIVATE ${HOST_SHADERS_INCLUDE}) target_link_libraries(video_core PRIVATE sirit::sirit) +target_link_libraries(video_core PRIVATE reshadefx::reshadefx stb::headers) # Header-only stuff needed by all dependent targets target_link_libraries(video_core PUBLIC Vulkan::Headers Vulkan::UtilityHeaders GPUOpen::VulkanMemoryAllocator) diff --git a/src/video_core/post_processing/fx_chain.cpp b/src/video_core/post_processing/fx_chain.cpp new file mode 100644 index 0000000000..f5983bbdd0 --- /dev/null +++ b/src/video_core/post_processing/fx_chain.cpp @@ -0,0 +1,285 @@ +// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project +// SPDX-License-Identifier: GPL-3.0-or-later + +#include +#include + +#include + +#include "common/settings.h" +#include "video_core/post_processing/fx_chain.h" +#include "video_core/post_processing/fx_effect.h" + +namespace VideoCore { + +namespace { + +std::vector Split(std::string_view value, char separator) { + std::vector out; + size_t start = 0; + while (start <= value.size()) { + size_t end = value.find(separator, start); + if (end == std::string_view::npos) { + end = value.size(); + } + out.push_back(value.substr(start, end - start)); + start = end + 1; + } + return out; +} + +bool IsSerializableName(std::string_view value) { + return value.find_first_of(";|,=") == std::string_view::npos; +} + +} // Anonymous namespace + +std::vector ParseFxChain(std::string_view value) { + std::vector parsed; + + for (const std::string_view record : Split(value, ';')) { + if (record.empty()) { + continue; + } + + const auto fields = Split(record, '|'); + if (fields.size() < 2 || fields[0].empty() || fields[1].empty()) { + continue; + } + + FxChainEntry entry; + entry.file = std::string(fields[0]); + entry.technique = std::string(fields[1]); + + if (fields.size() >= 3) { + for (const std::string_view assignment : Split(fields[2], ',')) { + const size_t equals = assignment.find('='); + if (equals == std::string_view::npos) { + continue; + } + const std::string name(assignment.substr(0, equals)); + if (name.empty()) { + continue; + } + + std::array components{}; + size_t index = 0; + for (const std::string_view piece : Split(assignment.substr(equals + 1), '/')) { + if (index >= components.size()) { + break; + } + const std::string text(piece); + if (!text.empty()) { + components[index] = std::strtof(text.c_str(), nullptr); + } + ++index; + } + entry.values.emplace(name, components); + } + } + + parsed.push_back(std::move(entry)); + } + + return parsed; +} + +std::string SerializeFxChain(std::span entries) { + std::string out; + + for (const auto& entry : entries) { + if (!IsSerializableName(entry.file) || !IsSerializableName(entry.technique)) { + continue; + } + if (!out.empty()) { + out += ';'; + } + out += entry.file; + out += '|'; + out += entry.technique; + out += '|'; + + bool first = true; + for (const auto& [name, value] : entry.values) { + if (!IsSerializableName(name)) { + continue; + } + if (!first) { + out += ','; + } + first = false; + out += name; + out += '='; + for (size_t i = 0; i < value.size(); ++i) { + if (i > 0) { + out += '/'; + } + out += fmt::format("{}", value[i]); + } + } + } + + return out; +} + +FxChain& FxChain::Instance() { + static FxChain instance; + return instance; +} + +FxChainSnapshot FxChain::Snapshot() const { + std::scoped_lock lock{mutex}; + return FxChainSnapshot{ + .entries = entries, + .generation = generation.load(std::memory_order_relaxed), + }; +} + +std::vector FxChain::Entries() const { + std::scoped_lock lock{mutex}; + return entries; +} + +size_t FxChain::Size() const { + std::scoped_lock lock{mutex}; + return entries.size(); +} + +void FxChain::Append(std::string_view file, std::string_view technique) { + { + std::scoped_lock lock{mutex}; + FxChainEntry entry; + entry.file = std::string(file); + entry.technique = std::string(technique); + entries.push_back(std::move(entry)); + } + generation.fetch_add(1, std::memory_order_relaxed); +} + +void FxChain::Replace(size_t index, std::string_view file, std::string_view technique) { + { + std::scoped_lock lock{mutex}; + if (index >= entries.size()) { + return; + } + if (entries[index].file == file && entries[index].technique == technique) { + return; + } + FxChainEntry entry; + entry.file = std::string(file); + entry.technique = std::string(technique); + entries[index] = std::move(entry); + } + generation.fetch_add(1, std::memory_order_relaxed); +} + +void FxChain::Remove(size_t index) { + { + std::scoped_lock lock{mutex}; + if (index >= entries.size()) { + return; + } + entries.erase(entries.begin() + static_cast(index)); + } + generation.fetch_add(1, std::memory_order_relaxed); +} + +void FxChain::Move(size_t index, int delta) { + { + std::scoped_lock lock{mutex}; + if (index >= entries.size()) { + return; + } + const std::ptrdiff_t target = static_cast(index) + delta; + if (target < 0 || target >= static_cast(entries.size())) { + return; + } + std::swap(entries[index], entries[static_cast(target)]); + } + generation.fetch_add(1, std::memory_order_relaxed); +} + +void FxChain::Clear() { + { + std::scoped_lock lock{mutex}; + entries.clear(); + } + generation.fetch_add(1, std::memory_order_relaxed); +} + +void FxChain::SetValue(size_t index, std::string_view uniform, const std::array& value) { + std::scoped_lock lock{mutex}; + if (index >= entries.size()) { + return; + } + entries[index].values[std::string(uniform)] = value; +} + +std::array FxChain::GetValue(size_t index, std::string_view uniform) const { + std::scoped_lock lock{mutex}; + if (index >= entries.size()) { + return {}; + } + const auto it = entries[index].values.find(std::string(uniform)); + if (it == entries[index].values.end()) { + return {}; + } + return it->second; +} + +bool FxChain::HasValue(size_t index, std::string_view uniform) const { + std::scoped_lock lock{mutex}; + if (index >= entries.size()) { + return false; + } + return entries[index].values.contains(std::string(uniform)); +} + +void FxChain::ResetValues(size_t index) { + std::scoped_lock lock{mutex}; + if (index >= entries.size()) { + return; + } + entries[index].values.clear(); +} + +void FxChain::LoadFromSettings() { + auto loaded = ParseFxChain(Settings::values.post_shader_chain.GetValue()); + + std::scoped_lock lock{mutex}; + entries = std::move(loaded); + generation.fetch_add(1, std::memory_order_relaxed); +} + +void FxChain::StoreToSettings() const { + std::string serialized; + { + std::scoped_lock lock{mutex}; + serialized = SerializeFxChain(entries); + } + Settings::values.post_shader_chain.SetValue(serialized); +} + +void FxChain::DropUnknownEntries() { + bool changed = false; + { + std::scoped_lock lock{mutex}; + const auto removed = std::remove_if(entries.begin(), entries.end(), [](const FxChainEntry& entry) { + const FxEffectDesc* effect = FindFxEffect(entry.file); + if (effect == nullptr || !effect->Valid()) { + return true; + } + return std::find(effect->techniques.begin(), effect->techniques.end(), + entry.technique) == effect->techniques.end(); + }); + if (removed != entries.end()) { + entries.erase(removed, entries.end()); + changed = true; + } + } + if (changed) { + generation.fetch_add(1, std::memory_order_relaxed); + } +} + +} // namespace VideoCore diff --git a/src/video_core/post_processing/fx_chain.h b/src/video_core/post_processing/fx_chain.h new file mode 100644 index 0000000000..a9ae5e401a --- /dev/null +++ b/src/video_core/post_processing/fx_chain.h @@ -0,0 +1,76 @@ +// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project +// SPDX-License-Identifier: GPL-3.0-or-later + +#pragma once + +#include +#include +#include +#include +#include +#include +#include +#include + +#include "common/common_types.h" + +namespace VideoCore { + +struct FxChainEntry { + std::string file; + std::string technique; + std::map> values; +}; + +struct FxChainSnapshot { + std::vector entries; + u64 generation{}; +}; + +std::vector ParseFxChain(std::string_view value); + +std::string SerializeFxChain(std::span entries); + +class FxChain { +public: + static FxChain& Instance(); + + FxChainSnapshot Snapshot() const; + + std::vector Entries() const; + + size_t Size() const; + + void Append(std::string_view file, std::string_view technique); + + void Replace(size_t index, std::string_view file, std::string_view technique); + + void Remove(size_t index); + + void Move(size_t index, int delta); + + void Clear(); + + void SetValue(size_t index, std::string_view uniform, const std::array& value); + + std::array GetValue(size_t index, std::string_view uniform) const; + + bool HasValue(size_t index, std::string_view uniform) const; + + void ResetValues(size_t index); + + void LoadFromSettings(); + + void StoreToSettings() const; + + void DropUnknownEntries(); + +private: + FxChain() = default; + + mutable std::mutex mutex; + std::vector entries; + std::atomic generation{1}; +}; + +} // namespace VideoCore diff --git a/src/video_core/post_processing/fx_compile.cpp b/src/video_core/post_processing/fx_compile.cpp new file mode 100644 index 0000000000..a933c0751d --- /dev/null +++ b/src/video_core/post_processing/fx_compile.cpp @@ -0,0 +1,105 @@ +// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project +// SPDX-License-Identifier: GPL-3.0-or-later + +#include +#include +#include + +#include "effect_codegen.hpp" +#include "effect_parser.hpp" +#include "effect_preprocessor.hpp" + +#include "common/fs/fs.h" +#include "common/fs/fs_util.h" +#include "video_core/post_processing/fx_compile.h" +#include "video_core/post_processing/fx_effect.h" + +namespace VideoCore { + +FxCompileResult CompileFxEffect(const std::filesystem::path& path, u32 width, u32 height, + u32 color_bit_depth) { + FxCompileResult result; + + if (!Common::FS::Exists(path)) { + result.error = "Effect file not found: " + Common::FS::PathToUTF8String(path); + return result; + } + + reshadefx::preprocessor preprocessor; + preprocessor.add_macro_definition("__RESHADE__", "50000"); + preprocessor.add_macro_definition("__RESHADE_PERFORMANCE_MODE__", "1"); + preprocessor.add_macro_definition("__RENDERER__", "0x20000"); + preprocessor.add_macro_definition("__VENDOR__", "0"); + preprocessor.add_macro_definition("__DEVICE__", "0"); + preprocessor.add_macro_definition("__APPLICATION__", "0"); + preprocessor.add_macro_definition("BUFFER_WIDTH", std::to_string(width)); + preprocessor.add_macro_definition("BUFFER_HEIGHT", std::to_string(height)); + preprocessor.add_macro_definition("BUFFER_RCP_WIDTH", "(1.0 / BUFFER_WIDTH)"); + preprocessor.add_macro_definition("BUFFER_RCP_HEIGHT", "(1.0 / BUFFER_HEIGHT)"); + preprocessor.add_macro_definition("BUFFER_COLOR_DEPTH", std::to_string(color_bit_depth)); + preprocessor.add_macro_definition("BUFFER_COLOR_BIT_DEPTH", std::to_string(color_bit_depth)); + + for (const auto& include : GetFxIncludePaths(path)) { + preprocessor.add_include_path(include); + } + + if (!preprocessor.append_file(path)) { + result.error = preprocessor.errors(); + if (result.error.empty()) { + result.error = "Failed to preprocess " + Common::FS::PathToUTF8String(path); + } + return result; + } + + std::unique_ptr backend( + reshadefx::create_codegen_spirv(true, false, false, false, false)); + + reshadefx::parser parser; + if (!parser.parse(preprocessor.output(), backend.get())) { + result.error = parser.errors(); + if (result.error.empty()) { + result.error = "Failed to parse " + Common::FS::PathToUTF8String(path); + } + return result; + } + + result.module = backend->module(); + + std::set wanted; + for (const auto& technique : result.module.techniques) { + for (const auto& pass : technique.passes) { + if (!pass.vs_entry_point.empty()) { + wanted.insert(pass.vs_entry_point); + } + if (!pass.ps_entry_point.empty()) { + wanted.insert(pass.ps_entry_point); + } + } + } + + for (const auto& name : wanted) { + std::string binary; + std::string assembly; + std::string errors; + if (!backend->assemble_code_for_entry_point(name, binary, assembly, errors)) { + result.error = "Failed to assemble entry point '" + name + "': " + errors; + return result; + } + if (binary.size() % sizeof(u32) != 0) { + result.error = "Entry point '" + name + "' produced a malformed SPIR-V module"; + return result; + } + + std::vector words(binary.size() / sizeof(u32)); + std::memcpy(words.data(), binary.data(), binary.size()); + result.entry_points.emplace(name, std::move(words)); + } + + if (result.entry_points.empty()) { + result.error = "Effect declares no usable entry points"; + } + + return result; +} + +} // namespace VideoCore diff --git a/src/video_core/post_processing/fx_compile.h b/src/video_core/post_processing/fx_compile.h new file mode 100644 index 0000000000..f4b70f3a2c --- /dev/null +++ b/src/video_core/post_processing/fx_compile.h @@ -0,0 +1,29 @@ +// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project +// SPDX-License-Identifier: GPL-3.0-or-later + +#pragma once + +#include +#include +#include +#include + +#include "common/common_types.h" +#include "effect_module.hpp" + +namespace VideoCore { + +struct FxCompileResult { + reshadefx::effect_module module; + std::map> entry_points; + std::string error; + + bool Succeeded() const { + return error.empty() && !entry_points.empty(); + } +}; + +FxCompileResult CompileFxEffect(const std::filesystem::path& path, u32 width, u32 height, + u32 color_bit_depth); + +} // namespace VideoCore diff --git a/src/video_core/post_processing/fx_effect.cpp b/src/video_core/post_processing/fx_effect.cpp new file mode 100644 index 0000000000..e483a8c0cc --- /dev/null +++ b/src/video_core/post_processing/fx_effect.cpp @@ -0,0 +1,283 @@ +// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project +// SPDX-License-Identifier: GPL-3.0-or-later + +#include + +#include "common/fs/fs.h" +#include "common/fs/fs_util.h" +#include "common/fs/path_util.h" +#include "common/logging.h" +#include "video_core/post_processing/fx_compile.h" +#include "video_core/post_processing/fx_effect.h" + +namespace VideoCore { + +namespace { + +constexpr u32 CATALOG_PROBE_WIDTH = 1280; +constexpr u32 CATALOG_PROBE_HEIGHT = 720; +constexpr u32 CATALOG_PROBE_DEPTH = 8; + +std::vector catalog; + +const reshadefx::annotation* FindAnnotation(const std::vector& annotations, + std::string_view name) { + const auto it = std::find_if(annotations.begin(), annotations.end(), + [&](const reshadefx::annotation& a) { return a.name == name; }); + if (it == annotations.end()) { + return nullptr; + } + return &*it; +} + +std::string AnnotationString(const std::vector& annotations, + std::string_view name) { + const reshadefx::annotation* a = FindAnnotation(annotations, name); + if (a == nullptr) { + return std::string(); + } + return a->value.string_data; +} + +bool AnnotationFloat(const std::vector& annotations, std::string_view name, + f32& out) { + const reshadefx::annotation* a = FindAnnotation(annotations, name); + if (a == nullptr) { + return false; + } + if (a->type.is_floating_point()) { + out = a->value.as_float[0]; + return true; + } + if (a->type.is_integral()) { + out = static_cast(a->value.as_int[0]); + return true; + } + return false; +} + +FxUiType ParseUiType(std::string_view value) { + if (value == "slider") { + return FxUiType::Slider; + } + if (value == "drag") { + return FxUiType::Drag; + } + if (value == "combo") { + return FxUiType::Combo; + } + if (value == "radio") { + return FxUiType::Radio; + } + if (value == "check" || value == "checkbox") { + return FxUiType::CheckBox; + } + if (value == "color") { + return FxUiType::Color; + } + if (value == "input") { + return FxUiType::InputBox; + } + return FxUiType::Hidden; +} + +std::vector SplitItems(const std::string& items) { + std::vector out; + std::string current; + for (const char c : items) { + if (c == '\0') { + out.push_back(current); + current.clear(); + continue; + } + current += c; + } + if (!current.empty()) { + out.push_back(current); + } + return out; +} + +FxUniformDesc DescribeUniform(const reshadefx::uniform& info) { + FxUniformDesc desc; + desc.name = info.name; + desc.components = std::min(info.type.components(), 4); + + if (info.type.is_boolean()) { + desc.kind = FxUniformKind::Bool; + } else if (info.type.is_integral()) { + desc.kind = FxUniformKind::Int; + } else { + desc.kind = FxUniformKind::Float; + } + + desc.label = AnnotationString(info.annotations, "ui_label"); + if (desc.label.empty()) { + desc.label = info.name; + } + desc.tooltip = AnnotationString(info.annotations, "ui_tooltip"); + desc.category = AnnotationString(info.annotations, "ui_category"); + desc.ui_type = ParseUiType(AnnotationString(info.annotations, "ui_type")); + desc.items = SplitItems(AnnotationString(info.annotations, "ui_items")); + + if (desc.kind == FxUniformKind::Bool) { + desc.ui_min = 0.0f; + desc.ui_max = 1.0f; + desc.ui_step = 1.0f; + } else if (desc.kind == FxUniformKind::Int) { + desc.ui_min = 0.0f; + desc.ui_max = 100.0f; + desc.ui_step = 1.0f; + } + + void(AnnotationFloat(info.annotations, "ui_min", desc.ui_min)); + void(AnnotationFloat(info.annotations, "ui_max", desc.ui_max)); + void(AnnotationFloat(info.annotations, "ui_step", desc.ui_step)); + + if (desc.ui_step <= 0.0f) { + desc.ui_step = 0.01f; + if (desc.kind != FxUniformKind::Float) { + desc.ui_step = 1.0f; + } + } + if (desc.ui_max < desc.ui_min) { + std::swap(desc.ui_min, desc.ui_max); + } + + if (info.has_initializer_value) { + for (u32 i = 0; i < desc.components; ++i) { + if (desc.kind == FxUniformKind::Float) { + desc.default_value[i] = info.initializer_value.as_float[i]; + } else { + desc.default_value[i] = static_cast(info.initializer_value.as_int[i]); + } + } + } + + return desc; +} + +FxEffectDesc DescribeEffect(const std::filesystem::path& path, const std::filesystem::path& root) { + FxEffectDesc desc; + desc.file = Common::FS::PathToUTF8String(std::filesystem::relative(path, root)); + desc.name = Common::FS::PathToUTF8String(path.stem()); + + const auto compiled = + CompileFxEffect(path, CATALOG_PROBE_WIDTH, CATALOG_PROBE_HEIGHT, CATALOG_PROBE_DEPTH); + if (!compiled.Succeeded()) { + desc.error = compiled.error; + return desc; + } + + for (const auto& technique : compiled.module.techniques) { + desc.techniques.push_back(technique.name); + } + + for (const auto& uniform : compiled.module.uniforms) { + FxUniformDesc uniform_desc = DescribeUniform(uniform); + if (uniform_desc.ui_type == FxUiType::Hidden) { + continue; + } + desc.uniforms.push_back(std::move(uniform_desc)); + } + + return desc; +} + +} // Anonymous namespace + +std::filesystem::path GetFxRootDirectory() { + return Common::FS::GetEdenPath(Common::FS::EdenPath::PostShaderDir); +} + +std::vector GetFxIncludePaths(const std::filesystem::path& effect_path) { + const auto root = GetFxRootDirectory(); + std::vector paths; + paths.push_back(effect_path.parent_path()); + paths.push_back(root); + paths.push_back(root / "Shaders"); + + const auto last = std::unique(paths.begin(), paths.end()); + paths.erase(last, paths.end()); + return paths; +} + +std::filesystem::path ResolveFxTexturePath(const std::filesystem::path& effect_path, + std::string_view source) { + const auto root = GetFxRootDirectory(); + const std::filesystem::path name{source}; + + const std::array candidates{ + effect_path.parent_path() / name, + root / "Textures" / name, + root / name, + }; + + for (const auto& candidate : candidates) { + if (Common::FS::Exists(candidate)) { + return candidate; + } + } + + return std::filesystem::path(); +} + +void ReloadFxCatalog() { + catalog.clear(); + + const auto root = GetFxRootDirectory(); + if (!Common::FS::Exists(root)) { + void(Common::FS::CreateDirs(root)); + return; + } + + std::vector effect_files; + Common::FS::IterateDirEntriesRecursively( + root, + [&](const std::filesystem::directory_entry& entry) { + if (entry.path().extension() == ".fx") { + effect_files.push_back(entry.path()); + } + return true; + }, + Common::FS::DirEntryFilter::File); + + std::sort(effect_files.begin(), effect_files.end()); + + for (const auto& file : effect_files) { + FxEffectDesc desc = DescribeEffect(file, root); + if (!desc.error.empty()) { + LOG_WARNING(Render, "Post-processing effect '{}' failed to compile:\n{}", desc.file, + desc.error); + } + catalog.push_back(std::move(desc)); + } + + const size_t usable = std::count_if(catalog.begin(), catalog.end(), + [](const FxEffectDesc& d) { return d.Valid(); }); + LOG_INFO(Render, "Loaded {} post-processing effects ({} usable)", catalog.size(), usable); +} + +const std::vector& GetFxCatalog() { + return catalog; +} + +const FxEffectDesc* FindFxEffect(std::string_view file) { + const auto it = std::find_if(catalog.begin(), catalog.end(), + [&](const FxEffectDesc& d) { return d.file == file; }); + if (it == catalog.end()) { + return nullptr; + } + return &*it; +} + +const FxUniformDesc* FindFxUniform(const FxEffectDesc& effect, std::string_view name) { + const auto it = std::find_if(effect.uniforms.begin(), effect.uniforms.end(), + [&](const FxUniformDesc& u) { return u.name == name; }); + if (it == effect.uniforms.end()) { + return nullptr; + } + return &*it; +} + +} // namespace VideoCore diff --git a/src/video_core/post_processing/fx_effect.h b/src/video_core/post_processing/fx_effect.h new file mode 100644 index 0000000000..4e0c4b0ae3 --- /dev/null +++ b/src/video_core/post_processing/fx_effect.h @@ -0,0 +1,75 @@ +// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project +// SPDX-License-Identifier: GPL-3.0-or-later + +#pragma once + +#include +#include +#include +#include +#include + +#include "common/common_types.h" + +namespace VideoCore { + +enum class FxUniformKind { + Bool, + Int, + Float, +}; + +enum class FxUiType { + Hidden, + Slider, + Drag, + Combo, + Radio, + CheckBox, + Color, + InputBox, +}; + +struct FxUniformDesc { + std::string name; + std::string label; + std::string tooltip; + std::string category; + FxUniformKind kind{FxUniformKind::Float}; + u32 components{1}; + FxUiType ui_type{FxUiType::Hidden}; + f32 ui_min{0.0f}; + f32 ui_max{1.0f}; + f32 ui_step{0.01f}; + std::vector items; + std::array default_value{}; +}; + +struct FxEffectDesc { + std::string file; + std::string name; + std::vector techniques; + std::vector uniforms; + std::string error; + + bool Valid() const { + return error.empty() && !techniques.empty(); + } +}; + +std::filesystem::path GetFxRootDirectory(); + +std::vector GetFxIncludePaths(const std::filesystem::path& effect_path); + +std::filesystem::path ResolveFxTexturePath(const std::filesystem::path& effect_path, + std::string_view source); + +void ReloadFxCatalog(); + +const std::vector& GetFxCatalog(); + +const FxEffectDesc* FindFxEffect(std::string_view file); + +const FxUniformDesc* FindFxUniform(const FxEffectDesc& effect, std::string_view name); + +} // namespace VideoCore diff --git a/src/video_core/renderer_vulkan/present/layer.cpp b/src/video_core/renderer_vulkan/present/layer.cpp index 14935f92bb..88fdfe4500 100644 --- a/src/video_core/renderer_vulkan/present/layer.cpp +++ b/src/video_core/renderer_vulkan/present/layer.cpp @@ -18,6 +18,8 @@ #include "video_core/renderer_vulkan/present/sgsr.h" #include "video_core/renderer_vulkan/present/fxaa.h" #include "video_core/renderer_vulkan/present/layer.h" +#include "video_core/post_processing/fx_chain.h" +#include "video_core/renderer_vulkan/present/post_process.h" #include "video_core/renderer_vulkan/present/present_push_constants.h" #include "video_core/renderer_vulkan/present/smaa.h" #include "video_core/renderer_vulkan/present/util.h" @@ -93,6 +95,7 @@ void Layer::ConfigureDraw(const Device& device, PresentPushConstants* out_push_c RefreshResources(device, framebuffer); SetAntiAliasPass(device); + SetPostProcessPass(device); // Finish any pending renderpass scheduler.RequestOutsideRenderPassOperationContext(); @@ -115,6 +118,10 @@ void Layer::ConfigureDraw(const Device& device, PresentPushConstants* out_push_c smaa->Draw(device, scheduler, image_index, &source_image, &source_image_view); } + if (post_process.has_value()) { + post_process->Draw(device, scheduler, image_index, &source_image, &source_image_view); + } + auto crop_rect = Tegra::NormalizeCrop(framebuffer, texture_width, texture_height); const VkExtent2D render_extent{ .width = scaled_width, @@ -214,6 +221,38 @@ void Layer::SetAntiAliasPass(const Device& device) { } } +void Layer::SetPostProcessPass(const Device& device) { + const VkExtent2D render_area{ + .width = Settings::values.resolution_info.ScaleUp(raw_width), + .height = Settings::values.resolution_info.ScaleUp(raw_height), + }; + + const u64 generation = VideoCore::FxChain::Instance().Snapshot().generation; + + if (post_process_generation == generation && post_process_extent.width == render_area.width && + post_process_extent.height == render_area.height) { + return; + } + + for (const u64 tick : resource_ticks) { + scheduler.Wait(tick); + } + + post_process_generation = generation; + post_process_extent = render_area; + post_process.reset(); + + if (VideoCore::FxChain::Instance().Size() == 0) { + return; + } + + post_process.emplace(device, memory_allocator, scheduler, image_count, render_area); + + if (post_process->Empty()) { + post_process.reset(); + } +} + void Layer::ReleaseRawImages() { for (const u64 tick : resource_ticks) { scheduler.Wait(tick); diff --git a/src/video_core/renderer_vulkan/present/layer.h b/src/video_core/renderer_vulkan/present/layer.h index 4d75e86ba6..73ada26613 100644 --- a/src/video_core/renderer_vulkan/present/layer.h +++ b/src/video_core/renderer_vulkan/present/layer.h @@ -15,6 +15,7 @@ #include "video_core/renderer_vulkan/present/fsr.h" #include "video_core/renderer_vulkan/present/sgsr.h" #include "video_core/renderer_vulkan/present/fxaa.h" +#include "video_core/renderer_vulkan/present/post_process.h" #include "video_core/renderer_vulkan/present/smaa.h" namespace Layout { @@ -66,6 +67,7 @@ private: void RefreshResources(const Device& device, const Tegra::FramebufferConfig& framebuffer); void SetAntiAliasPass(const Device& device); + void SetPostProcessPass(const Device& device); void ReleaseRawImages(); u64 CalculateBufferSize(const Tegra::FramebufferConfig& framebuffer) const; @@ -95,6 +97,9 @@ private: Settings::AntiAliasing anti_alias_setting{}; std::variant anti_alias{}; std::variant sr_filter{}; + std::optional post_process{}; + u64 post_process_generation{}; + VkExtent2D post_process_extent{}; std::vector resource_ticks{}; }; diff --git a/src/video_core/renderer_vulkan/present/post_process.cpp b/src/video_core/renderer_vulkan/present/post_process.cpp new file mode 100644 index 0000000000..fa0e121a41 --- /dev/null +++ b/src/video_core/renderer_vulkan/present/post_process.cpp @@ -0,0 +1,899 @@ +// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project +// SPDX-License-Identifier: GPL-3.0-or-later + +#include +#include +#include + +#include "common/fs/fs.h" +#include "common/fs/fs_util.h" +#include "common/logging.h" +#include "common/stb.h" +#include "video_core/post_processing/fx_chain.h" +#include "video_core/post_processing/fx_compile.h" +#include "video_core/post_processing/fx_effect.h" +#include "video_core/renderer_vulkan/present/post_process.h" +#include "video_core/renderer_vulkan/present/util.h" +#include "video_core/renderer_vulkan/vk_scheduler.h" +#include "video_core/vulkan_common/vulkan_device.h" + +namespace Vulkan { + +namespace { + +constexpr VkFormat BACKBUFFER_FORMAT = VK_FORMAT_R16G16B16A16_SFLOAT; +constexpr size_t NO_TEXTURE = ~size_t{0}; + +VkFormat ToVkFormat(reshadefx::texture_format format) { + switch (format) { + case reshadefx::texture_format::r8: + return VK_FORMAT_R8_UNORM; + case reshadefx::texture_format::r16f: + return VK_FORMAT_R16_SFLOAT; + case reshadefx::texture_format::r32f: + return VK_FORMAT_R32_SFLOAT; + case reshadefx::texture_format::rg8: + return VK_FORMAT_R8G8_UNORM; + case reshadefx::texture_format::rg16: + return VK_FORMAT_R16G16_UNORM; + case reshadefx::texture_format::rg16f: + return VK_FORMAT_R16G16_SFLOAT; + case reshadefx::texture_format::rg32f: + return VK_FORMAT_R32G32_SFLOAT; + case reshadefx::texture_format::rgba8: + return VK_FORMAT_R8G8B8A8_UNORM; + case reshadefx::texture_format::rgba16: + return VK_FORMAT_R16G16B16A16_UNORM; + case reshadefx::texture_format::rgba16f: + return VK_FORMAT_R16G16B16A16_SFLOAT; + case reshadefx::texture_format::rgba32f: + return VK_FORMAT_R32G32B32A32_SFLOAT; + case reshadefx::texture_format::rgb10a2: + return VK_FORMAT_A2B10G10R10_UNORM_PACK32; + default: + return VK_FORMAT_R8G8B8A8_UNORM; + } +} + +VkSamplerAddressMode ToAddressMode(reshadefx::texture_address_mode mode) { + switch (mode) { + case reshadefx::texture_address_mode::wrap: + return VK_SAMPLER_ADDRESS_MODE_REPEAT; + case reshadefx::texture_address_mode::mirror: + return VK_SAMPLER_ADDRESS_MODE_MIRRORED_REPEAT; + case reshadefx::texture_address_mode::border: + return VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_BORDER; + case reshadefx::texture_address_mode::clamp: + default: + return VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE; + } +} + +VkBlendFactor ToBlendFactor(reshadefx::blend_factor func) { + switch (func) { + case reshadefx::blend_factor::zero: + return VK_BLEND_FACTOR_ZERO; + case reshadefx::blend_factor::source_color: + return VK_BLEND_FACTOR_SRC_COLOR; + case reshadefx::blend_factor::source_alpha: + return VK_BLEND_FACTOR_SRC_ALPHA; + case reshadefx::blend_factor::one_minus_source_color: + return VK_BLEND_FACTOR_ONE_MINUS_SRC_COLOR; + case reshadefx::blend_factor::one_minus_source_alpha: + return VK_BLEND_FACTOR_ONE_MINUS_SRC_ALPHA; + case reshadefx::blend_factor::dest_color: + return VK_BLEND_FACTOR_DST_COLOR; + case reshadefx::blend_factor::dest_alpha: + return VK_BLEND_FACTOR_DST_ALPHA; + case reshadefx::blend_factor::one_minus_dest_color: + return VK_BLEND_FACTOR_ONE_MINUS_DST_COLOR; + case reshadefx::blend_factor::one_minus_dest_alpha: + return VK_BLEND_FACTOR_ONE_MINUS_DST_ALPHA; + case reshadefx::blend_factor::one: + default: + return VK_BLEND_FACTOR_ONE; + } +} + +VkBlendOp ToBlendOp(reshadefx::blend_op op) { + switch (op) { + case reshadefx::blend_op::subtract: + return VK_BLEND_OP_SUBTRACT; + case reshadefx::blend_op::reverse_subtract: + return VK_BLEND_OP_REVERSE_SUBTRACT; + case reshadefx::blend_op::min: + return VK_BLEND_OP_MIN; + case reshadefx::blend_op::max: + return VK_BLEND_OP_MAX; + case reshadefx::blend_op::add: + default: + return VK_BLEND_OP_ADD; + } +} + +VkPrimitiveTopology ToTopology(reshadefx::primitive_topology topology) { + switch (topology) { + case reshadefx::primitive_topology::point_list: + return VK_PRIMITIVE_TOPOLOGY_POINT_LIST; + case reshadefx::primitive_topology::line_list: + return VK_PRIMITIVE_TOPOLOGY_LINE_LIST; + case reshadefx::primitive_topology::line_strip: + return VK_PRIMITIVE_TOPOLOGY_LINE_STRIP; + case reshadefx::primitive_topology::triangle_strip: + return VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP; + case reshadefx::primitive_topology::triangle_list: + default: + return VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST; + } +} + +vk::RenderPass CreateFxRenderPass(const Device& device, VkFormat format, bool clear) { + VkAttachmentLoadOp load_op = VK_ATTACHMENT_LOAD_OP_LOAD; + VkImageLayout initial_layout = VK_IMAGE_LAYOUT_GENERAL; + if (clear) { + load_op = VK_ATTACHMENT_LOAD_OP_CLEAR; + initial_layout = VK_IMAGE_LAYOUT_UNDEFINED; + } + + const VkAttachmentDescription attachment{ + .flags = 0, + .format = format, + .samples = VK_SAMPLE_COUNT_1_BIT, + .loadOp = load_op, + .storeOp = VK_ATTACHMENT_STORE_OP_STORE, + .stencilLoadOp = VK_ATTACHMENT_LOAD_OP_DONT_CARE, + .stencilStoreOp = VK_ATTACHMENT_STORE_OP_DONT_CARE, + .initialLayout = initial_layout, + .finalLayout = VK_IMAGE_LAYOUT_GENERAL, + }; + + const VkAttachmentReference reference{ + .attachment = 0, + .layout = VK_IMAGE_LAYOUT_GENERAL, + }; + + const VkSubpassDescription subpass{ + .flags = 0, + .pipelineBindPoint = VK_PIPELINE_BIND_POINT_GRAPHICS, + .inputAttachmentCount = 0, + .pInputAttachments = nullptr, + .colorAttachmentCount = 1, + .pColorAttachments = &reference, + .pResolveAttachments = nullptr, + .pDepthStencilAttachment = nullptr, + .preserveAttachmentCount = 0, + .pPreserveAttachments = nullptr, + }; + + return device.GetLogical().CreateRenderPass(VkRenderPassCreateInfo{ + .sType = VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO, + .pNext = nullptr, + .flags = 0, + .attachmentCount = 1, + .pAttachments = &attachment, + .subpassCount = 1, + .pSubpasses = &subpass, + .dependencyCount = 0, + .pDependencies = nullptr, + }); +} + +vk::Pipeline CreateFxPipeline(const Device& device, vk::RenderPass& renderpass, + vk::PipelineLayout& layout, VkShaderModule vertex_shader, + VkShaderModule fragment_shader, + const reshadefx::pass& pass) { + const std::array stages{{ + { + .sType = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO, + .pNext = nullptr, + .flags = 0, + .stage = VK_SHADER_STAGE_VERTEX_BIT, + .module = vertex_shader, + .pName = pass.vs_entry_point.c_str(), + .pSpecializationInfo = nullptr, + }, + { + .sType = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO, + .pNext = nullptr, + .flags = 0, + .stage = VK_SHADER_STAGE_FRAGMENT_BIT, + .module = fragment_shader, + .pName = pass.ps_entry_point.c_str(), + .pSpecializationInfo = nullptr, + }, + }}; + + constexpr VkPipelineVertexInputStateCreateInfo vertex_input{ + .sType = VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO, + .pNext = nullptr, + .flags = 0, + .vertexBindingDescriptionCount = 0, + .pVertexBindingDescriptions = nullptr, + .vertexAttributeDescriptionCount = 0, + .pVertexAttributeDescriptions = nullptr, + }; + + const VkPipelineInputAssemblyStateCreateInfo input_assembly{ + .sType = VK_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO, + .pNext = nullptr, + .flags = 0, + .topology = ToTopology(pass.topology), + .primitiveRestartEnable = VK_FALSE, + }; + + constexpr VkPipelineViewportStateCreateInfo viewport_state{ + .sType = VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO, + .pNext = nullptr, + .flags = 0, + .viewportCount = 1, + .pViewports = nullptr, + .scissorCount = 1, + .pScissors = nullptr, + }; + + constexpr VkPipelineRasterizationStateCreateInfo rasterization{ + .sType = VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_CREATE_INFO, + .pNext = nullptr, + .flags = 0, + .depthClampEnable = VK_FALSE, + .rasterizerDiscardEnable = VK_FALSE, + .polygonMode = VK_POLYGON_MODE_FILL, + .cullMode = VK_CULL_MODE_NONE, + .frontFace = VK_FRONT_FACE_COUNTER_CLOCKWISE, + .depthBiasEnable = VK_FALSE, + .depthBiasConstantFactor = 0.0f, + .depthBiasClamp = 0.0f, + .depthBiasSlopeFactor = 0.0f, + .lineWidth = 1.0f, + }; + + constexpr VkPipelineMultisampleStateCreateInfo multisampling{ + .sType = VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO, + .pNext = nullptr, + .flags = 0, + .rasterizationSamples = VK_SAMPLE_COUNT_1_BIT, + .sampleShadingEnable = VK_FALSE, + .minSampleShading = 0.0f, + .pSampleMask = nullptr, + .alphaToCoverageEnable = VK_FALSE, + .alphaToOneEnable = VK_FALSE, + }; + + VkBool32 blend_enable = VK_FALSE; + if (pass.blend_enable[0]) { + blend_enable = VK_TRUE; + } + + const VkPipelineColorBlendAttachmentState blending{ + .blendEnable = blend_enable, + .srcColorBlendFactor = ToBlendFactor(pass.source_color_blend_factor[0]), + .dstColorBlendFactor = ToBlendFactor(pass.dest_color_blend_factor[0]), + .colorBlendOp = ToBlendOp(pass.color_blend_op[0]), + .srcAlphaBlendFactor = ToBlendFactor(pass.source_alpha_blend_factor[0]), + .dstAlphaBlendFactor = ToBlendFactor(pass.dest_alpha_blend_factor[0]), + .alphaBlendOp = ToBlendOp(pass.alpha_blend_op[0]), + .colorWriteMask = static_cast(pass.render_target_write_mask[0] & 0xF), + }; + + const VkPipelineColorBlendStateCreateInfo color_blend{ + .sType = VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO, + .pNext = nullptr, + .flags = 0, + .logicOpEnable = VK_FALSE, + .logicOp = VK_LOGIC_OP_COPY, + .attachmentCount = 1, + .pAttachments = &blending, + .blendConstants = {0.0f, 0.0f, 0.0f, 0.0f}, + }; + + constexpr std::array dynamic_states{ + VK_DYNAMIC_STATE_VIEWPORT, + VK_DYNAMIC_STATE_SCISSOR, + }; + + const VkPipelineDynamicStateCreateInfo dynamic_state{ + .sType = VK_STRUCTURE_TYPE_PIPELINE_DYNAMIC_STATE_CREATE_INFO, + .pNext = nullptr, + .flags = 0, + .dynamicStateCount = static_cast(dynamic_states.size()), + .pDynamicStates = dynamic_states.data(), + }; + + return device.GetLogical().CreateGraphicsPipeline(VkGraphicsPipelineCreateInfo{ + .sType = VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO, + .pNext = nullptr, + .flags = 0, + .stageCount = static_cast(stages.size()), + .pStages = stages.data(), + .pVertexInputState = &vertex_input, + .pInputAssemblyState = &input_assembly, + .pTessellationState = nullptr, + .pViewportState = &viewport_state, + .pRasterizationState = &rasterization, + .pMultisampleState = &multisampling, + .pDepthStencilState = nullptr, + .pColorBlendState = &color_blend, + .pDynamicState = &dynamic_state, + .layout = *layout, + .renderPass = *renderpass, + .subpass = 0, + .basePipelineHandle = nullptr, + .basePipelineIndex = 0, + }); +} + +} // Anonymous namespace + +PostProcessChain::PostProcessChain(const Device& device, MemoryAllocator& allocator, + Scheduler& scheduler, size_t image_count, VkExtent2D extent) + : m_extent(extent) + , m_image_count(u32(image_count)) +{ + m_start = std::chrono::steady_clock::now(); + m_previous = m_start; + + CreatePingPongImages(device, allocator); + + m_fallback_sampler = CreateWrappedSampler(device); + m_fallback_image = CreateWrappedImage(allocator, VkExtent2D{1, 1}, VK_FORMAT_R8G8B8A8_UNORM); + m_fallback_view = CreateWrappedImageView(device, m_fallback_image, VK_FORMAT_R8G8B8A8_UNORM); + + if (!BuildEffects(device, allocator, scheduler)) { + m_effects.clear(); + } +} + +PostProcessChain::~PostProcessChain() = default; + +bool PostProcessChain::Empty() const { + return m_effects.empty(); +} + +void PostProcessChain::CreatePingPongImages(const Device& device, MemoryAllocator& allocator) { + m_frames.resize(m_image_count); + for (auto& frame : m_frames) { + for (size_t i = 0; i < frame.images.size(); ++i) { + frame.images[i] = CreateWrappedImage(allocator, m_extent, BACKBUFFER_FORMAT); + frame.views[i] = CreateWrappedImageView(device, frame.images[i], BACKBUFFER_FORMAT); + } + } +} + +bool PostProcessChain::BuildEffects(const Device& device, MemoryAllocator& allocator, + Scheduler& scheduler) { + const auto snapshot = VideoCore::FxChain::Instance().Snapshot(); + if (snapshot.entries.empty()) { + return true; + } + + const auto root = VideoCore::GetFxRootDirectory(); + + for (size_t entry_index = 0; entry_index < snapshot.entries.size(); ++entry_index) { + const auto& entry = snapshot.entries[entry_index]; + const auto path = root / entry.file; + + const auto compiled = VideoCore::CompileFxEffect(path, m_extent.width, m_extent.height, 8); + if (!compiled.Succeeded()) { + LOG_ERROR(Render_Vulkan, "Post-processing effect '{}' failed to compile:\n{}", + entry.file, compiled.error); + continue; + } + + const auto& module = compiled.module; + + const auto technique = std::find_if( + module.techniques.begin(), module.techniques.end(), + [&](const reshadefx::technique& t) { return t.name == entry.technique; }); + if (technique == module.techniques.end()) { + LOG_ERROR(Render_Vulkan, "Effect '{}' has no technique '{}'", entry.file, + entry.technique); + continue; + } + + Effect effect; + effect.entry_index = entry_index; + effect.file = entry.file; + effect.uniform_size = module.total_uniform_size; + for (const auto& [name, words] : compiled.entry_points) { + effect.shaders.emplace(name, CreateWrappedShaderModule(device, words)); + } + + for (const auto& texture : module.textures) { + Texture out; + out.name = texture.unique_name; + out.extent = VkExtent2D{texture.width, texture.height}; + out.format = ToVkFormat(texture.format); + + if (texture.semantic == "COLOR") { + out.is_backbuffer = true; + effect.textures.push_back(std::move(out)); + continue; + } + if (texture.semantic == "DEPTH") { + effect.textures.push_back(std::move(out)); + continue; + } + + out.image = CreateWrappedImage(allocator, out.extent, out.format); + out.view = CreateWrappedImageView(device, out.image, out.format); + effect.textures.push_back(std::move(out)); + } + + for (const auto& sampler : module.samplers) { + Sampler out; + out.texture_index = NO_TEXTURE; + for (size_t i = 0; i < effect.textures.size(); ++i) { + if (effect.textures[i].name == sampler.texture_name) { + out.texture_index = i; + break; + } + } + + VkFilter mag_filter = VK_FILTER_LINEAR; + VkFilter min_filter = VK_FILTER_LINEAR; + VkSamplerMipmapMode mip_mode = VK_SAMPLER_MIPMAP_MODE_LINEAR; + const u32 filter = static_cast(sampler.filter); + if ((filter & 0x10) == 0) { + min_filter = VK_FILTER_NEAREST; + } + if ((filter & 0x04) == 0) { + mag_filter = VK_FILTER_NEAREST; + } + if ((filter & 0x01) == 0) { + mip_mode = VK_SAMPLER_MIPMAP_MODE_NEAREST; + } + + out.sampler = device.GetLogical().CreateSampler(VkSamplerCreateInfo{ + .sType = VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO, + .pNext = nullptr, + .flags = 0, + .magFilter = mag_filter, + .minFilter = min_filter, + .mipmapMode = mip_mode, + .addressModeU = ToAddressMode(sampler.address_u), + .addressModeV = ToAddressMode(sampler.address_v), + .addressModeW = ToAddressMode(sampler.address_w), + .mipLodBias = sampler.lod_bias, + .anisotropyEnable = VK_FALSE, + .maxAnisotropy = 1.0f, + .compareEnable = VK_FALSE, + .compareOp = VK_COMPARE_OP_NEVER, + .minLod = sampler.min_lod, + .maxLod = sampler.max_lod, + .borderColor = VK_BORDER_COLOR_FLOAT_TRANSPARENT_BLACK, + .unnormalizedCoordinates = VK_FALSE, + }); + + effect.samplers.push_back(std::move(out)); + } + + for (const auto& uniform : module.uniforms) { + UniformWrite write; + write.name = uniform.name; + write.offset = uniform.offset; + write.components = std::min(uniform.type.components(), 4); + write.kind = UniformKind::Floating; + if (uniform.type.is_boolean()) { + write.kind = UniformKind::Boolean; + } else if (uniform.type.is_integral()) { + write.kind = UniformKind::Integer; + } + + for (const auto& annotation : uniform.annotations) { + if (annotation.name != "source") { + continue; + } + const std::string& source = annotation.value.string_data; + if (source == "frametime") { + write.source = UniformSource::FrameTime; + } else if (source == "framecount") { + write.source = UniformSource::FrameCount; + } else if (source == "timer") { + write.source = UniformSource::Timer; + } else if (source == "random") { + write.source = UniformSource::Random; + } else if (source == "pingpong") { + write.source = UniformSource::PingPong; + } + } + + if (uniform.has_initializer_value) { + for (u32 i = 0; i < write.components; ++i) { + if (write.kind == UniformKind::Floating) { + write.fallback[i] = uniform.initializer_value.as_float[i]; + } else { + write.fallback[i] = static_cast(uniform.initializer_value.as_int[i]); + } + } + } + + const auto override = entry.values.find(uniform.name); + if (override != entry.values.end()) { + write.fallback = override->second; + } + + write.args = {0.0f, 1.0f, 1.0f, 0.0f}; + for (const auto& annotation : uniform.annotations) { + if (annotation.name == "min" && annotation.type.is_floating_point()) { + write.args[0] = annotation.value.as_float[0]; + } + if (annotation.name == "max" && annotation.type.is_floating_point()) { + write.args[1] = annotation.value.as_float[0]; + } + if (annotation.name == "step" && annotation.type.is_floating_point()) { + write.args[2] = annotation.value.as_float[0]; + } + } + write.state = write.args[0]; + + effect.uniforms.push_back(std::move(write)); + } + + effect.uniform_layout = CreateWrappedDescriptorSetLayout( + device, std::array{VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER}, + VK_SHADER_STAGE_VERTEX_BIT | VK_SHADER_STAGE_FRAGMENT_BIT); + + for (const auto& pass : technique->passes) { + Pass out; + out.num_vertices = pass.num_vertices; + out.clear = pass.clear_render_targets != 0; + out.target_texture = NO_TEXTURE; + out.extent = m_extent; + + const std::string& target = pass.render_target_names[0]; + if (target.empty()) { + out.writes_backbuffer = true; + } else { + for (size_t i = 0; i < effect.textures.size(); ++i) { + if (effect.textures[i].name == target) { + out.target_texture = i; + out.extent = effect.textures[i].extent; + break; + } + } + if (out.target_texture == NO_TEXTURE) { + LOG_WARNING(Render_Vulkan, "Effect '{}' pass targets unknown texture '{}'", + entry.file, target); + out.writes_backbuffer = true; + } + } + + if (pass.viewport_width != 0 && pass.viewport_height != 0) { + out.extent = VkExtent2D{pass.viewport_width, pass.viewport_height}; + } + + VkFormat target_format = BACKBUFFER_FORMAT; + if (!out.writes_backbuffer) { + target_format = effect.textures[out.target_texture].format; + } + + u32 binding_count = 0; + for (const auto& binding : pass.sampler_bindings) { + SamplerBinding entry_binding; + entry_binding.binding = binding.entry_point_binding; + entry_binding.sampler_index = binding.index; + out.sampler_bindings.push_back(entry_binding); + binding_count = std::max(binding_count, binding.entry_point_binding + 1); + } + + const std::vector sampler_types( + std::max(binding_count, 1), VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER); + out.sampler_layout = CreateWrappedDescriptorSetLayout( + device, sampler_types, VK_SHADER_STAGE_VERTEX_BIT | VK_SHADER_STAGE_FRAGMENT_BIT); + + const std::array set_layouts{*effect.uniform_layout, *out.sampler_layout}; + out.pipeline_layout = + device.GetLogical().CreatePipelineLayout(VkPipelineLayoutCreateInfo{ + .sType = VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO, + .pNext = nullptr, + .flags = 0, + .setLayoutCount = static_cast(set_layouts.size()), + .pSetLayouts = set_layouts.data(), + .pushConstantRangeCount = 0, + .pPushConstantRanges = nullptr, + }); + + const auto vertex_shader = effect.shaders.find(pass.vs_entry_point); + const auto fragment_shader = effect.shaders.find(pass.ps_entry_point); + if (vertex_shader == effect.shaders.end() || + fragment_shader == effect.shaders.end()) { + LOG_WARNING(Render_Vulkan, "Effect '{}' pass references a missing entry point", + entry.file); + continue; + } + + out.renderpass = CreateFxRenderPass(device, target_format, out.clear); + out.pipeline = CreateFxPipeline(device, out.renderpass, out.pipeline_layout, + *vertex_shader->second, *fragment_shader->second, pass); + + if (out.writes_backbuffer) { + out.backbuffer_slot = static_cast(effect.backbuffer_pass_count % 2); + ++effect.backbuffer_pass_count; + for (u32 image = 0; image < m_image_count; ++image) { + for (size_t slot = 0; slot < 2; ++slot) { + out.framebuffers.push_back(CreateWrappedFramebuffer( + device, out.renderpass, m_frames[image].views[slot], out.extent)); + } + } + } else { + out.framebuffers.push_back( + CreateWrappedFramebuffer(device, out.renderpass, + effect.textures[out.target_texture].view, out.extent)); + } + + effect.passes.push_back(std::move(out)); + } + + if (effect.passes.empty()) { + LOG_WARNING(Render_Vulkan, "Effect '{}' technique '{}' has no passes", entry.file, + entry.technique); + continue; + } + + const u32 buffer_size = std::max(effect.uniform_size, 4); + for (u32 i = 0; i < m_image_count; ++i) { + effect.uniform_buffers.push_back( + CreateWrappedBuffer(allocator, buffer_size, MemoryUsage::Upload)); + } + + size_t sampler_descriptor_count = 0; + size_t sampler_set_count = 0; + for (const auto& pass : effect.passes) { + sampler_descriptor_count += + m_image_count * std::max(pass.sampler_bindings.size(), 1); + sampler_set_count += m_image_count; + } + + effect.descriptor_pool = CreateWrappedDescriptorPool( + device, m_image_count + sampler_descriptor_count, m_image_count + sampler_set_count, + {VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER, VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER}); + + const std::vector uniform_layouts(m_image_count, + *effect.uniform_layout); + effect.uniform_sets = CreateWrappedDescriptorSets(effect.descriptor_pool, uniform_layouts); + + for (auto& pass : effect.passes) { + const std::vector layouts(m_image_count, *pass.sampler_layout); + pass.sampler_sets = CreateWrappedDescriptorSets(effect.descriptor_pool, layouts); + } + + m_effects.push_back(std::move(effect)); + } + + return true; +} + +void PostProcessChain::PrepareImages(const Device& device, Scheduler& scheduler) { + if (m_images_ready) { + return; + } + + scheduler.Record([this](vk::CommandBuffer cmdbuf) { + ClearColorImage(cmdbuf, *m_fallback_image); + for (auto& frame : m_frames) { + for (auto& image : frame.images) { + ClearColorImage(cmdbuf, *image); + } + } + for (auto& effect : m_effects) { + for (auto& texture : effect.textures) { + if (texture.image) { + ClearColorImage(cmdbuf, *texture.image); + } + } + } + }); + scheduler.Finish(); + + m_images_ready = true; +} + +void PostProcessChain::UpdateUniforms(Effect& effect, size_t image_index, f32 delta_seconds) { + if (effect.uniform_size == 0) { + return; + } + + static thread_local std::mt19937 rng{std::random_device{}()}; + + std::vector staging(effect.uniform_size, 0); + const f32 elapsed = + std::chrono::duration(std::chrono::steady_clock::now() - m_start).count(); + + for (auto& uniform : effect.uniforms) { + std::array value = uniform.fallback; + + switch (uniform.source) { + case UniformSource::FrameTime: + value[0] = delta_seconds * 1000.0f; + break; + case UniformSource::FrameCount: + value[0] = static_cast(m_frame_count); + break; + case UniformSource::Timer: + value[0] = elapsed * 1000.0f; + break; + case UniformSource::Random: { + const int low = static_cast(uniform.args[0]); + int high = static_cast(uniform.args[1]); + if (high <= low) { + high = low + 1; + } + std::uniform_int_distribution dist(low, high); + value[0] = static_cast(dist(rng)); + break; + } + case UniformSource::PingPong: { + const f32 min_value = uniform.args[0]; + f32 max_value = uniform.args[1]; + if (max_value <= min_value) { + max_value = min_value + 1.0f; + } + f32 step = uniform.args[2]; + if (step == 0.0f) { + step = 1.0f; + } + uniform.state += uniform.direction * step * delta_seconds; + if (uniform.state >= max_value) { + uniform.state = max_value; + uniform.direction = -1.0f; + } + if (uniform.state <= min_value) { + uniform.state = min_value; + uniform.direction = 1.0f; + } + value[0] = uniform.state; + value[1] = uniform.direction; + break; + } + case UniformSource::Value: + default: + break; + } + + for (u32 i = 0; i < uniform.components; ++i) { + const size_t offset = uniform.offset + i * sizeof(u32); + if (offset + sizeof(u32) > staging.size()) { + break; + } + if (uniform.kind == UniformKind::Floating) { + const f32 element = value[i]; + std::memcpy(staging.data() + offset, &element, sizeof(f32)); + } else { + const s32 element = static_cast(value[i]); + std::memcpy(staging.data() + offset, &element, sizeof(s32)); + } + } + } + + const std::span mapped = effect.uniform_buffers[image_index].Mapped(); + if (mapped.size() >= staging.size()) { + std::memcpy(mapped.data(), staging.data(), staging.size()); + effect.uniform_buffers[image_index].Flush(); + } +} + +void PostProcessChain::UpdateDescriptors(const Device& device, Effect& effect, Pass& pass, + size_t image_index, VkImageView backbuffer_view) { + std::vector image_infos; + std::vector writes; + image_infos.reserve(pass.sampler_bindings.size() + 1); + + const VkDescriptorSet sampler_set = pass.sampler_sets[image_index]; + + for (const auto& binding : pass.sampler_bindings) { + VkImageView view = *m_fallback_view; + VkSampler handle = *m_fallback_sampler; + + if (binding.sampler_index < effect.samplers.size()) { + const Sampler& sampler = effect.samplers[binding.sampler_index]; + if (sampler.sampler) { + handle = *sampler.sampler; + } + if (sampler.texture_index != NO_TEXTURE) { + const Texture& texture = effect.textures[sampler.texture_index]; + if (texture.is_backbuffer) { + view = backbuffer_view; + } else if (texture.view) { + view = *texture.view; + } + } + } + + writes.push_back( + CreateWriteDescriptorSet(image_infos, handle, view, sampler_set, binding.binding)); + } + + const VkDescriptorBufferInfo buffer_info{ + .buffer = *effect.uniform_buffers[image_index], + .offset = 0, + .range = VK_WHOLE_SIZE, + }; + + writes.push_back(VkWriteDescriptorSet{ + .sType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET, + .pNext = nullptr, + .dstSet = effect.uniform_sets[image_index], + .dstBinding = 0, + .dstArrayElement = 0, + .descriptorCount = 1, + .descriptorType = VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER, + .pImageInfo = nullptr, + .pBufferInfo = &buffer_info, + .pTexelBufferView = nullptr, + }); + + device.GetLogical().UpdateDescriptorSets(writes, {}); +} + +void PostProcessChain::Draw(const Device& device, Scheduler& scheduler, size_t image_index, + VkImage* inout_image, VkImageView* inout_image_view) { + if (m_effects.empty()) { + return; + } + + PrepareImages(device, scheduler); + + const auto now = std::chrono::steady_clock::now(); + const f32 delta_seconds = std::chrono::duration(now - m_previous).count(); + m_previous = now; + ++m_frame_count; + + FrameImages& frame = m_frames[image_index]; + VkImage current_image = *inout_image; + VkImageView current_view = *inout_image_view; + u32 slot = 0; + + for (auto& effect : m_effects) { + UpdateUniforms(effect, image_index, delta_seconds); + + for (size_t pass_index = 0; pass_index < effect.passes.size(); ++pass_index) { + Pass& pass = effect.passes[pass_index]; + + UpdateDescriptors(device, effect, pass, image_index, current_view); + + VkFramebuffer framebuffer{}; + VkImage target_image{}; + if (pass.writes_backbuffer) { + const u32 target_slot = (slot + 1) % 2; + framebuffer = *pass.framebuffers[image_index * 2 + target_slot]; + target_image = *frame.images[target_slot]; + } else { + framebuffer = *pass.framebuffers[0]; + target_image = *effect.textures[pass.target_texture].image; + } + + const VkImage source_image = current_image; + const VkRenderPass renderpass = *pass.renderpass; + const VkPipeline pipeline = *pass.pipeline; + const VkPipelineLayout layout = *pass.pipeline_layout; + const VkDescriptorSet uniform_set = effect.uniform_sets[image_index]; + const VkDescriptorSet sampler_set = pass.sampler_sets[image_index]; + const VkExtent2D extent = pass.extent; + const u32 vertices = pass.num_vertices; + + scheduler.RequestOutsideRenderPassOperationContext(); + scheduler.Record([=](vk::CommandBuffer cmdbuf) { + TransitionImageLayout(cmdbuf, source_image, VK_IMAGE_LAYOUT_GENERAL); + TransitionImageLayout(cmdbuf, target_image, VK_IMAGE_LAYOUT_GENERAL); + BeginRenderPass(cmdbuf, renderpass, framebuffer, extent); + cmdbuf.BindPipeline(VK_PIPELINE_BIND_POINT_GRAPHICS, pipeline); + cmdbuf.BindDescriptorSets(VK_PIPELINE_BIND_POINT_GRAPHICS, layout, 0, + std::array{uniform_set, sampler_set}, {}); + cmdbuf.Draw(vertices, 1, 0, 0); + cmdbuf.EndRenderPass(); + TransitionImageLayout(cmdbuf, target_image, VK_IMAGE_LAYOUT_GENERAL); + }); + + if (pass.writes_backbuffer) { + slot = (slot + 1) % 2; + current_image = *frame.images[slot]; + current_view = *frame.views[slot]; + } + } + } + + *inout_image = current_image; + *inout_image_view = current_view; +} + +} // namespace Vulkan diff --git a/src/video_core/renderer_vulkan/present/post_process.h b/src/video_core/renderer_vulkan/present/post_process.h new file mode 100644 index 0000000000..9d42bd4751 --- /dev/null +++ b/src/video_core/renderer_vulkan/present/post_process.h @@ -0,0 +1,140 @@ +// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project +// SPDX-License-Identifier: GPL-3.0-or-later + +#pragma once + +#include +#include +#include +#include +#include + +#include "common/common_types.h" +#include "video_core/vulkan_common/vulkan_memory_allocator.h" +#include "video_core/vulkan_common/vulkan_wrapper.h" + +namespace Vulkan { + +class Device; +class Scheduler; + +class PostProcessChain { +public: + explicit PostProcessChain(const Device& device, MemoryAllocator& allocator, Scheduler& scheduler, + size_t image_count, VkExtent2D extent); + ~PostProcessChain(); + + void Draw(const Device& device, Scheduler& scheduler, size_t image_index, VkImage* inout_image, + VkImageView* inout_image_view); + + bool Empty() const; + +private: + enum class UniformKind : u32 { + Boolean, + Integer, + Floating, + }; + + enum class UniformSource : u32 { + Value, + FrameTime, + FrameCount, + Timer, + Random, + PingPong, + }; + + struct UniformWrite { + std::string name; + u32 offset{}; + u32 components{}; + UniformKind kind{UniformKind::Floating}; + UniformSource source{UniformSource::Value}; + std::array fallback{}; + std::array args{}; + f32 state{}; + f32 direction{1.0f}; + }; + + struct Texture { + std::string name; + vk::Image image{}; + vk::ImageView view{}; + VkExtent2D extent{}; + VkFormat format{}; + bool is_backbuffer{}; + }; + + struct Sampler { + vk::Sampler sampler{}; + size_t texture_index{}; + }; + + struct SamplerBinding { + u32 binding{}; + size_t sampler_index{}; + }; + + struct Pass { + vk::RenderPass renderpass{}; + vk::Pipeline pipeline{}; + vk::DescriptorSetLayout sampler_layout{}; + vk::PipelineLayout pipeline_layout{}; + vk::DescriptorSets sampler_sets{}; + std::vector sampler_bindings{}; + std::vector framebuffers{}; + size_t target_texture{}; + VkExtent2D extent{}; + u32 num_vertices{3}; + bool clear{}; + bool writes_backbuffer{}; + u32 backbuffer_slot{}; + }; + + struct Effect { + size_t entry_index{}; + std::string file{}; + std::map shaders{}; + std::vector textures{}; + std::vector samplers{}; + std::vector passes{}; + std::vector uniforms{}; + u32 uniform_size{}; + std::vector uniform_buffers{}; + vk::DescriptorSetLayout uniform_layout{}; + vk::DescriptorPool descriptor_pool{}; + vk::DescriptorSets uniform_sets{}; + size_t backbuffer_pass_count{}; + u32 backbuffer_slots{1}; + }; + + struct FrameImages { + std::array images{}; + std::array views{}; + }; + + bool BuildEffects(const Device& device, MemoryAllocator& allocator, Scheduler& scheduler); + void CreatePingPongImages(const Device& device, MemoryAllocator& allocator); + void PrepareImages(const Device& device, Scheduler& scheduler); + void UpdateUniforms(Effect& effect, size_t image_index, f32 delta_seconds); + void UpdateDescriptors(const Device& device, Effect& effect, Pass& pass, size_t image_index, + VkImageView backbuffer_view); + + const VkExtent2D m_extent; + const u32 m_image_count; + + std::vector m_effects{}; + std::vector m_frames{}; + + vk::Sampler m_fallback_sampler{}; + vk::Image m_fallback_image{}; + vk::ImageView m_fallback_view{}; + + std::chrono::steady_clock::time_point m_start{}; + std::chrono::steady_clock::time_point m_previous{}; + u64 m_frame_count{}; + bool m_images_ready{}; +}; + +} // namespace Vulkan diff --git a/src/video_core/renderer_vulkan/renderer_vulkan.cpp b/src/video_core/renderer_vulkan/renderer_vulkan.cpp index 6290e79d93..0350e09692 100644 --- a/src/video_core/renderer_vulkan/renderer_vulkan.cpp +++ b/src/video_core/renderer_vulkan/renderer_vulkan.cpp @@ -24,6 +24,8 @@ #include "video_core/gpu.h" #include "video_core/present.h" #include "video_core/renderer_vulkan/present/util.h" +#include "video_core/post_processing/fx_chain.h" +#include "video_core/post_processing/fx_effect.h" #include "video_core/renderer_vulkan/renderer_vulkan.h" #include "video_core/renderer_vulkan/vk_blit_screen.h" #include "video_core/renderer_vulkan/vk_rasterizer.h" @@ -183,6 +185,10 @@ try scheduler.RegisterOnSubmit([this] { turbo_mode->QueueSubmitted(); }); } + VideoCore::ReloadFxCatalog(); + VideoCore::FxChain::Instance().LoadFromSettings(); + VideoCore::FxChain::Instance().DropUnknownEntries(); + Report(); } catch (const vk::Exception& exception) { LOG_ERROR(Render_Vulkan, "Vulkan initialization failed with error: {}", exception.what()); diff --git a/src/yuzu/CMakeLists.txt b/src/yuzu/CMakeLists.txt index 021ed9ee3e..184cf7968e 100644 --- a/src/yuzu/CMakeLists.txt +++ b/src/yuzu/CMakeLists.txt @@ -74,6 +74,8 @@ add_executable(yuzu configuration/configure_general.ui configuration/configure_graphics.cpp configuration/configure_graphics.h + configuration/configure_post_processing.cpp + configuration/configure_post_processing.h configuration/configure_graphics.ui configuration/configure_graphics_advanced.cpp configuration/configure_graphics_advanced.h diff --git a/src/yuzu/configuration/configure_post_processing.cpp b/src/yuzu/configuration/configure_post_processing.cpp new file mode 100644 index 0000000000..94c828f529 --- /dev/null +++ b/src/yuzu/configuration/configure_post_processing.cpp @@ -0,0 +1,378 @@ +// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project +// SPDX-License-Identifier: GPL-3.0-or-later + +#include +#include +#include + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include "common/fs/fs.h" +#include "common/fs/fs_util.h" +#include "video_core/post_processing/fx_chain.h" +#include "video_core/post_processing/fx_effect.h" +#include "yuzu/configuration/configure_post_processing.h" + +namespace { + +std::array CurrentValue(int index, const VideoCore::FxUniformDesc& uniform) { + auto& chain = VideoCore::FxChain::Instance(); + if (chain.HasValue(static_cast(index), uniform.name)) { + return chain.GetValue(static_cast(index), uniform.name); + } + return uniform.default_value; +} + +int SliderSteps(const VideoCore::FxUniformDesc& uniform) { + const float span = uniform.ui_max - uniform.ui_min; + const int steps = static_cast(std::lround(span / uniform.ui_step)); + if (steps < 1) { + return 1; + } + return steps; +} + +QString FormatValue(const VideoCore::FxUniformDesc& uniform, float value) { + if (uniform.kind == VideoCore::FxUniformKind::Float) { + return QString::number(value, 'f', 3); + } + return QString::number(static_cast(std::lround(value))); +} + +QString SlotLabel(const VideoCore::FxEffectDesc& effect, const std::string& technique) { + const QString name = QString::fromStdString(effect.name); + if (effect.techniques.size() == 1) { + return name; + } + return name + QStringLiteral(" · ") + QString::fromStdString(technique); +} + +} // Anonymous namespace + +ConfigurePostProcessing::ConfigurePostProcessing(QWidget* parent) : QDialog(parent) { + setWindowTitle(tr("Post-Processing Effects")); + setMinimumWidth(560); + setMinimumHeight(460); + + auto* root = new QVBoxLayout(this); + + auto* description = new QLabel( + tr("ReShade FX effects are loaded from the post_shaders folder in the Eden data " + "directory. Changes apply immediately while a game is running."), + this); + description->setWordWrap(true); + root->addWidget(description); + + auto* scroll = new QScrollArea(this); + scroll->setWidgetResizable(true); + slots_container = new QWidget(scroll); + slots_layout = new QVBoxLayout(slots_container); + slots_layout->setAlignment(Qt::AlignTop); + scroll->setWidget(slots_container); + root->addWidget(scroll, 1); + + auto* actions = new QHBoxLayout(); + + auto* add_button = new QPushButton(tr("Add Effect"), this); + connect(add_button, &QPushButton::clicked, this, [this]() { + for (const auto& effect : VideoCore::GetFxCatalog()) { + if (!effect.Valid()) { + continue; + } + VideoCore::FxChain::Instance().Append(effect.file, effect.techniques.front()); + ApplyStructuralChange(); + return; + } + }); + actions->addWidget(add_button); + + auto* reload_button = new QPushButton(tr("Reload From Disk"), this); + connect(reload_button, &QPushButton::clicked, this, [this]() { + VideoCore::ReloadFxCatalog(); + VideoCore::FxChain::Instance().DropUnknownEntries(); + ApplyStructuralChange(); + }); + actions->addWidget(reload_button); + + auto* open_button = new QPushButton(tr("Open Folder"), this); + connect(open_button, &QPushButton::clicked, this, []() { + const auto path = VideoCore::GetFxRootDirectory(); + void(Common::FS::CreateDirs(path)); + QDesktopServices::openUrl( + QUrl::fromLocalFile(QString::fromStdString(Common::FS::PathToUTF8String(path)))); + }); + actions->addWidget(open_button); + + actions->addStretch(); + root->addLayout(actions); + + auto* buttons = new QDialogButtonBox(QDialogButtonBox::Close, this); + connect(buttons, &QDialogButtonBox::rejected, this, &QDialog::close); + root->addWidget(buttons); + + RebuildRows(); +} + +ConfigurePostProcessing::~ConfigurePostProcessing() = default; + +void ConfigurePostProcessing::ApplyStructuralChange() { + VideoCore::FxChain::Instance().StoreToSettings(); + RebuildRows(); +} + +void ConfigurePostProcessing::PopulateEffectCombo(QComboBox* combo, + const VideoCore::FxChainEntry& entry) const { + combo->clear(); + int selected = -1; + + for (const auto& effect : VideoCore::GetFxCatalog()) { + if (!effect.Valid()) { + continue; + } + for (const auto& technique : effect.techniques) { + const QString key = QString::fromStdString(effect.file + "|" + technique); + combo->addItem(SlotLabel(effect, technique), key); + if (effect.file == entry.file && technique == entry.technique) { + selected = combo->count() - 1; + } + } + } + + if (selected >= 0) { + combo->setCurrentIndex(selected); + } +} + +void ConfigurePostProcessing::BuildUniformWidget(QWidget* parent, QVBoxLayout* layout, int index, + const VideoCore::FxUniformDesc& uniform) { + const auto value = CurrentValue(index, uniform); + const QString label = QString::fromStdString(uniform.label); + + if (uniform.ui_type == VideoCore::FxUiType::CheckBox) { + auto* box = new QCheckBox(label, parent); + box->setChecked(value[0] != 0.0f); + if (!uniform.tooltip.empty()) { + box->setToolTip(QString::fromStdString(uniform.tooltip)); + } + const std::string name = uniform.name; + connect(box, &QCheckBox::toggled, this, [index, name](bool checked) { + std::array next{}; + if (checked) { + next[0] = 1.0f; + } + VideoCore::FxChain::Instance().SetValue(static_cast(index), name, next); + VideoCore::FxChain::Instance().StoreToSettings(); + }); + layout->addWidget(box); + return; + } + + if (uniform.ui_type == VideoCore::FxUiType::Combo || + uniform.ui_type == VideoCore::FxUiType::Radio) { + auto* row = new QHBoxLayout(); + row->addWidget(new QLabel(label, parent)); + auto* combo = new QComboBox(parent); + for (size_t i = 0; i < uniform.items.size(); ++i) { + combo->addItem(QString::fromStdString(uniform.items[i]), static_cast(i)); + } + if (combo->count() == 0) { + combo->addItem(tr("Enabled"), 1); + combo->addItem(tr("Disabled"), 0); + } + const int current = static_cast(std::lround(value[0])); + if (current >= 0 && current < combo->count()) { + combo->setCurrentIndex(current); + } + if (!uniform.tooltip.empty()) { + combo->setToolTip(QString::fromStdString(uniform.tooltip)); + } + const std::string name = uniform.name; + connect(combo, &QComboBox::currentIndexChanged, this, [index, name](int selected) { + std::array next{}; + next[0] = static_cast(selected); + VideoCore::FxChain::Instance().SetValue(static_cast(index), name, next); + VideoCore::FxChain::Instance().StoreToSettings(); + }); + row->addWidget(combo, 1); + layout->addLayout(row); + return; + } + + auto* grid = new QGridLayout(); + for (unsigned component = 0; component < uniform.components; ++component) { + QString component_label = label; + if (uniform.components > 1) { + component_label = label + QStringLiteral(" [%1]").arg(component); + } + + auto* name_label = new QLabel(component_label, parent); + auto* value_label = new QLabel(parent); + value_label->setMinimumWidth(64); + value_label->setAlignment(Qt::AlignRight | Qt::AlignVCenter); + value_label->setText(FormatValue(uniform, value[component])); + + auto* slider = new QSlider(Qt::Horizontal, parent); + slider->setMinimum(0); + slider->setMaximum(SliderSteps(uniform)); + slider->setValue( + static_cast(std::lround((value[component] - uniform.ui_min) / uniform.ui_step))); + if (!uniform.tooltip.empty()) { + slider->setToolTip(QString::fromStdString(uniform.tooltip)); + } + + const std::string name = uniform.name; + const auto desc = uniform; + connect(slider, &QSlider::valueChanged, this, + [index, name, desc, component, value_label](int steps) { + auto next = CurrentValue(index, desc); + next[component] = desc.ui_min + static_cast(steps) * desc.ui_step; + VideoCore::FxChain::Instance().SetValue(static_cast(index), name, next); + value_label->setText(FormatValue(desc, next[component])); + }); + connect(slider, &QSlider::sliderReleased, this, + []() { VideoCore::FxChain::Instance().StoreToSettings(); }); + + grid->addWidget(name_label, static_cast(component), 0); + grid->addWidget(slider, static_cast(component), 1); + grid->addWidget(value_label, static_cast(component), 2); + } + layout->addLayout(grid); +} + +QWidget* ConfigurePostProcessing::BuildSlot(int index, const VideoCore::FxChainEntry& entry) { + auto* group = new QGroupBox(slots_container); + auto* layout = new QVBoxLayout(group); + + auto* header = new QHBoxLayout(); + + auto* combo = new QComboBox(group); + PopulateEffectCombo(combo, entry); + connect(combo, &QComboBox::currentIndexChanged, this, [this, index, combo](int) { + const QString key = combo->currentData().toString(); + const int separator = key.indexOf(QLatin1Char('|')); + if (separator < 0) { + return; + } + VideoCore::FxChain::Instance().Replace(static_cast(index), + key.left(separator).toStdString(), + key.mid(separator + 1).toStdString()); + ApplyStructuralChange(); + }); + header->addWidget(combo, 1); + + auto* up_button = new QToolButton(group); + up_button->setText(QStringLiteral("▲")); + up_button->setEnabled(index > 0); + connect(up_button, &QToolButton::clicked, this, [this, index]() { + VideoCore::FxChain::Instance().Move(static_cast(index), -1); + ApplyStructuralChange(); + }); + header->addWidget(up_button); + + auto* down_button = new QToolButton(group); + down_button->setText(QStringLiteral("▼")); + down_button->setEnabled(static_cast(index) + 1 < VideoCore::FxChain::Instance().Size()); + connect(down_button, &QToolButton::clicked, this, [this, index]() { + VideoCore::FxChain::Instance().Move(static_cast(index), 1); + ApplyStructuralChange(); + }); + header->addWidget(down_button); + + auto* reset_button = new QToolButton(group); + reset_button->setText(QStringLiteral("⟲")); + reset_button->setToolTip(tr("Reset to defaults")); + connect(reset_button, &QToolButton::clicked, this, [this, index]() { + VideoCore::FxChain::Instance().ResetValues(static_cast(index)); + ApplyStructuralChange(); + }); + header->addWidget(reset_button); + + auto* remove_button = new QToolButton(group); + remove_button->setText(QStringLiteral("✕")); + connect(remove_button, &QToolButton::clicked, this, [this, index]() { + VideoCore::FxChain::Instance().Remove(static_cast(index)); + ApplyStructuralChange(); + }); + header->addWidget(remove_button); + + layout->addLayout(header); + + const VideoCore::FxEffectDesc* effect = VideoCore::FindFxEffect(entry.file); + if (effect == nullptr) { + auto* missing = + new QLabel(tr("Effect '%1' was not found.").arg(QString::fromStdString(entry.file)), + group); + missing->setWordWrap(true); + layout->addWidget(missing); + return group; + } + + if (!effect->error.empty()) { + auto* failed = new QLabel( + tr("Effect failed to compile:\n%1").arg(QString::fromStdString(effect->error)), group); + failed->setWordWrap(true); + layout->addWidget(failed); + return group; + } + + std::string current_category; + for (const auto& uniform : effect->uniforms) { + if (uniform.category != current_category) { + current_category = uniform.category; + if (!current_category.empty()) { + auto* category = new QLabel(QString::fromStdString(current_category), group); + category->setStyleSheet(QStringLiteral("font-weight: bold;")); + layout->addWidget(category); + } + } + BuildUniformWidget(group, layout, index, uniform); + } + + return group; +} + +void ConfigurePostProcessing::RebuildRows() { + QLayoutItem* item = nullptr; + while ((item = slots_layout->takeAt(0)) != nullptr) { + if (item->widget() != nullptr) { + item->widget()->deleteLater(); + } + delete item; + } + + bool has_usable = false; + for (const auto& effect : VideoCore::GetFxCatalog()) { + if (effect.Valid()) { + has_usable = true; + break; + } + } + + if (!has_usable) { + auto* empty = new QLabel( + tr("No usable ReShade FX effects were found. Place .fx files in the post_shaders " + "folder."), + slots_container); + empty->setWordWrap(true); + slots_layout->addWidget(empty); + return; + } + + const auto entries = VideoCore::FxChain::Instance().Entries(); + for (size_t i = 0; i < entries.size(); ++i) { + slots_layout->addWidget(BuildSlot(static_cast(i), entries[i])); + } +} diff --git a/src/yuzu/configuration/configure_post_processing.h b/src/yuzu/configuration/configure_post_processing.h new file mode 100644 index 0000000000..d9d40e230f --- /dev/null +++ b/src/yuzu/configuration/configure_post_processing.h @@ -0,0 +1,35 @@ +// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project +// SPDX-License-Identifier: GPL-3.0-or-later + +#pragma once + +#include + +class QComboBox; +class QVBoxLayout; +class QWidget; + +namespace VideoCore { +struct FxChainEntry; +struct FxEffectDesc; +struct FxUniformDesc; +} + +class ConfigurePostProcessing : public QDialog { + Q_OBJECT + +public: + explicit ConfigurePostProcessing(QWidget* parent = nullptr); + ~ConfigurePostProcessing() override; + +private: + void RebuildRows(); + QWidget* BuildSlot(int index, const VideoCore::FxChainEntry& entry); + void BuildUniformWidget(QWidget* parent, QVBoxLayout* layout, int index, + const VideoCore::FxUniformDesc& uniform); + void PopulateEffectCombo(QComboBox* combo, const VideoCore::FxChainEntry& entry) const; + void ApplyStructuralChange(); + + QVBoxLayout* slots_layout{}; + QWidget* slots_container{}; +}; diff --git a/src/yuzu/main.ui b/src/yuzu/main.ui index c858be3cb3..d1248fac6c 100644 --- a/src/yuzu/main.ui +++ b/src/yuzu/main.ui @@ -148,6 +148,7 @@ + @@ -610,6 +611,11 @@ Show &Performance Overlay + + + Post-Processing &Shaders... + + true diff --git a/src/yuzu/main_window.cpp b/src/yuzu/main_window.cpp index 27b018d9d9..3a5b25f400 100644 --- a/src/yuzu/main_window.cpp +++ b/src/yuzu/main_window.cpp @@ -13,6 +13,7 @@ #include "common/settings_enums.h" #include "frontend_common/settings_generator.h" #include "render/performance_overlay.h" +#include "configuration/configure_post_processing.h" #include "updater/update_dialog.h" #include "common/fs/ryujinx_compat.h" @@ -1518,6 +1519,7 @@ void MainWindow::ConnectMenuEvents() { connect_menu(ui->action_Show_Filter_Bar, &MainWindow::OnToggleFilterBar); connect_menu(ui->action_Show_Status_Bar, &MainWindow::OnToggleStatusBar); connect_menu(ui->action_Show_Performance_Overlay, &MainWindow::OnTogglePerfOverlay); + connect_menu(ui->action_Post_Processing_Shaders, &MainWindow::OnPostProcessingShaders); connect_menu(ui->action_Reset_Window_Size_720, &MainWindow::ResetWindowSize720); connect_menu(ui->action_Reset_Window_Size_900, &MainWindow::ResetWindowSize900); @@ -3900,6 +3902,20 @@ void MainWindow::OnTogglePerfOverlay() { perf_overlay->setVisible(ui->action_Show_Performance_Overlay->isChecked()); } +void MainWindow::OnPostProcessingShaders() { + if (post_processing_dialog == nullptr) { + post_processing_dialog = new ConfigurePostProcessing(this); + connect(post_processing_dialog, &QDialog::finished, post_processing_dialog, [this]() { + post_processing_dialog->deleteLater(); + post_processing_dialog = nullptr; + }); + } + + post_processing_dialog->show(); + post_processing_dialog->raise(); + post_processing_dialog->activateWindow(); +} + void MainWindow::OnGameListRefresh() { // Resets metadata cache and reloads QtCommon::Game::ResetMetadata(false); diff --git a/src/yuzu/main_window.h b/src/yuzu/main_window.h index 3fe7ec620f..78864f719c 100644 --- a/src/yuzu/main_window.h +++ b/src/yuzu/main_window.h @@ -56,6 +56,7 @@ class QSlider; class QHBoxLayout; class WaitTreeWidget; class PerformanceOverlay; +class ConfigurePostProcessing; enum class GameListOpenTarget; enum class DumpRomFSTarget; class GameListPlaceholder; @@ -392,6 +393,7 @@ private slots: void OnToggleFilterBar(); void OnToggleStatusBar(); void OnTogglePerfOverlay(); + void OnPostProcessingShaders(); void OnGameListRefresh(); void InitializeHotkeys(); void ToggleFullscreen(); @@ -496,6 +498,7 @@ private: QTimer shutdown_timer; OverlayDialog* shutdown_dialog{}; PerformanceOverlay* perf_overlay = nullptr; + ConfigurePostProcessing* post_processing_dialog = nullptr; GameListPlaceholder* game_list_placeholder = nullptr;