diff options
Diffstat (limited to 'hosts/iroha/gentoo/patches')
8 files changed, 845 insertions, 138 deletions
diff --git a/hosts/iroha/gentoo/patches/app-misc/neofetch/neofetch_hostcolor.diff b/hosts/iroha/gentoo/patches/app-misc/neofetch/neofetch_hostcolor.diff new file mode 100644 index 0000000..cb4bdb5 --- /dev/null +++ b/hosts/iroha/gentoo/patches/app-misc/neofetch/neofetch_hostcolor.diff @@ -0,0 +1,24 @@ +--- a/neofetch 2025-07-24 14:35:25.646237301 -0400 ++++ b/neofetch 2025-07-24 14:34:57.393924725 -0400 +@@ -1386,8 +1386,8 @@ + on) hostname=$(hostname -f) ;; + *) hostname=${HOSTNAME:-$(hostname)} ;; + esac +- +- title=${title_color}${bold}${user}${at_color}@${title_color}${bold}${hostname} ++ host_color=${HOSTCOLOR:-${title_color}} ++ title=${title_color}${bold}${user}${at_color}@${host_color}${bold}${hostname} + length=$((${#user} + ${#hostname} + 1)) + } + +@@ -4604,8 +4604,8 @@ + fi + + string="$(trim "${string//$'\e[0m'}")" +- length="$(strip_sequences "$string")" +- length="${#length}" ++ #length="$(strip_sequences "$string")" ++ #length="${#length}" + + # Format the output. + string="${string/:/${reset}${colon_color}${separator:=:}${info_color}}" diff --git a/hosts/iroha/gentoo/patches/app-misc/neofetch/neofetch_kitty_font.diff b/hosts/iroha/gentoo/patches/app-misc/neofetch/neofetch_kitty_font.diff new file mode 100644 index 0000000..5021746 --- /dev/null +++ b/hosts/iroha/gentoo/patches/app-misc/neofetch/neofetch_kitty_font.diff @@ -0,0 +1,17 @@ +--- a/neofetch 2025-07-24 14:38:08.897043445 -0400 ++++ b/neofetch 2025-07-30 08:35:41.870152352 -0400 +@@ -3301,11 +3301,9 @@ + ;; + + "kitty"*) +- kitty_config="$(kitty --debug-config)" +- [[ "$kitty_config" != *font_family* ]] && return +- +- term_font="$(awk '/^font_family|^font_size/ {$1="";gsub("^ *","",$0);print $0}' \ +- <<< "$kitty_config")" ++ term_font="from kitty.cli import *; o = create_default_opts(); \ ++ print(f'{o.font_family} {o.font_size}')" ++ term_font="$(kitty +runpy ''"$term_font"'')" + ;; + + "konsole" | "yakuake") diff --git a/hosts/iroha/gentoo/patches/app-misc/ufetch/ufetch_hostcolor.diff b/hosts/iroha/gentoo/patches/app-misc/ufetch/ufetch_hostcolor.diff new file mode 100644 index 0000000..efccd68 --- /dev/null +++ b/hosts/iroha/gentoo/patches/app-misc/ufetch/ufetch_hostcolor.diff @@ -0,0 +1,27 @@ +--- a/ufetch-gentoo 2025-07-28 12:44:02.768490943 -0400 ++++ b/ufetch-gentoo 2025-07-28 12:45:58.575888260 -0400 +@@ -64,7 +64,8 @@ + + # you can change these + lc="${reset}${bold}${magenta}" # labels +-nc="${reset}${bold}${magenta}" # user and hostname ++nc="${reset}${bold}${magenta}" # user ++hc="${reset}${bold}${cyan}" # hostname + ic="${reset}" # info + c0="${reset}${bold}${magenta}" # first color + c1="${reset}${magenta}" # second color +@@ -72,13 +73,11 @@ + ## OUTPUT + + cat <<EOF +- +-${c0} .-----. ${nc}${USER}${ic}@${nc}${host}${reset} ++${c0} .-----. ${nc}${USER}${ic}@${hc}${host}${reset} + ${c0} .\` _ \`. ${lc}OS: ${ic}${os}${reset} + ${c0} \`. (${c1}_) ${c0}\`. ${lc}KERNEL: ${ic}${kernel}${reset} + ${c0} \`${c1}. / ${lc}UPTIME: ${ic}${uptime}${reset} + ${c1} .\` .\` ${lc}PACKAGES: ${ic}${packages}${reset} + ${c1} / .\` ${lc}SHELL: ${ic}${shell}${reset} + ${c1} \____.-\` ${lc}${uitype}: ${ic}${ui}${reset} +- + EOF diff --git a/hosts/iroha/gentoo/patches/games-util/xone/3bc363c48ec38c4a08c4294ca111ed9f75e3e026.diff b/hosts/iroha/gentoo/patches/games-util/xone/3bc363c48ec38c4a08c4294ca111ed9f75e3e026.diff deleted file mode 100644 index f133faf..0000000 --- a/hosts/iroha/gentoo/patches/games-util/xone/3bc363c48ec38c4a08c4294ca111ed9f75e3e026.diff +++ /dev/null @@ -1,26 +0,0 @@ -diff --git a/driver/headset.c b/driver/headset.c -index 5eada22..4c6e73e 100644 ---- a/driver/headset.c -+++ b/driver/headset.c -@@ -6,6 +6,7 @@ - #include <linux/module.h> - #include <linux/hrtimer.h> - #include <linux/vmalloc.h> -+#include <linux/version.h> - #include <sound/core.h> - #include <sound/initval.h> - #include <sound/pcm.h> -@@ -499,8 +500,13 @@ static int gip_headset_probe(struct gip_client *client) - INIT_DELAYED_WORK(&headset->work_power_on, gip_headset_power_on); - INIT_WORK(&headset->work_register, gip_headset_register); - -+#if LINUX_VERSION_CODE >= KERNEL_VERSION(6,15,0) -+ hrtimer_setup(&headset->timer, gip_headset_send_samples, -+ CLOCK_MONOTONIC, HRTIMER_MODE_REL); -+#else - hrtimer_init(&headset->timer, CLOCK_MONOTONIC, HRTIMER_MODE_REL); - headset->timer.function = gip_headset_send_samples; -+#endif - - err = gip_enable_audio(client); - if (err) diff --git a/hosts/iroha/gentoo/patches/games-util/xone/53.diff b/hosts/iroha/gentoo/patches/games-util/xone/53.diff deleted file mode 100644 index 455452a..0000000 --- a/hosts/iroha/gentoo/patches/games-util/xone/53.diff +++ /dev/null @@ -1,75 +0,0 @@ -diff --git a/bus/bus.c b/bus/bus.c -index 4a6c64f..8dc9bbb 100644 ---- a/bus/bus.c -+++ b/bus/bus.c -@@ -56,7 +56,11 @@ static struct device_type gip_client_type = { - .release = gip_client_release, - }; - -+#if LINUX_VERSION_CODE < KERNEL_VERSION(6, 11, 0) - static int gip_bus_match(struct device *dev, struct device_driver *driver) -+#else -+static int gip_bus_match(struct device *dev, const struct device_driver *driver) -+#endif - { - struct gip_client *client; - struct gip_driver *drv; -diff --git a/driver/headset.c b/driver/headset.c -index ebee92d..c736351 100644 ---- a/driver/headset.c -+++ b/driver/headset.c -@@ -5,6 +5,7 @@ - - #include <linux/module.h> - #include <linux/hrtimer.h> -+#include <linux/vmalloc.h> - #include <sound/core.h> - #include <sound/initval.h> - #include <sound/pcm.h> -@@ -90,13 +91,34 @@ static int gip_headset_pcm_close(struct snd_pcm_substream *sub) - static int gip_headset_pcm_hw_params(struct snd_pcm_substream *sub, - struct snd_pcm_hw_params *params) - { -- return snd_pcm_lib_alloc_vmalloc_buffer(sub, -- params_buffer_bytes(params)); -+ struct snd_pcm_runtime *runtime = sub->runtime; -+ size_t size = params_buffer_bytes(params); -+ -+ if (runtime->dma_area) { -+ if (runtime->dma_bytes >= size) -+ return 0; /* Already large enough */ -+ vfree(runtime->dma_area); -+ } -+ runtime->dma_area = vzalloc(size); -+ if (!runtime->dma_area) -+ return -ENOMEM; -+ runtime->dma_bytes = size; -+ return 1; - } - - static int gip_headset_pcm_hw_free(struct snd_pcm_substream *sub) - { -- return snd_pcm_lib_free_vmalloc_buffer(sub); -+ struct snd_pcm_runtime *runtime = sub->runtime; -+ -+ vfree(runtime->dma_area); -+ runtime->dma_area = NULL; -+ return 0; -+} -+ -+static struct page *gip_headset_pcm_get_page(struct snd_pcm_substream *sub, -+ unsigned long offset) -+{ -+ return vmalloc_to_page(sub->runtime->dma_area + offset); - } - - static int gip_headset_pcm_prepare(struct snd_pcm_substream *sub) -@@ -157,7 +179,7 @@ static const struct snd_pcm_ops gip_headset_pcm_ops = { - .prepare = gip_headset_pcm_prepare, - .trigger = gip_headset_pcm_trigger, - .pointer = gip_headset_pcm_pointer, -- .page = snd_pcm_lib_get_vmalloc_page, -+ .page = gip_headset_pcm_get_page, - }; - - static bool gip_headset_advance_pointer(struct gip_headset_stream *stream, diff --git a/hosts/iroha/gentoo/patches/games-util/xone/b18d6d5b51c308bca665e6dfe63f31aecb98cce5.diff b/hosts/iroha/gentoo/patches/games-util/xone/b18d6d5b51c308bca665e6dfe63f31aecb98cce5.diff deleted file mode 100644 index 7b23358..0000000 --- a/hosts/iroha/gentoo/patches/games-util/xone/b18d6d5b51c308bca665e6dfe63f31aecb98cce5.diff +++ /dev/null @@ -1,37 +0,0 @@ -diff --git a/driver/gamepad.c b/driver/gamepad.c -index eec2aeaa..d424774b 100644 ---- a/driver/gamepad.c -+++ b/driver/gamepad.c -@@ -6,6 +6,7 @@ - #include <linux/module.h> - #include <linux/uuid.h> - #include <linux/timer.h> -+#include <linux/version.h> - - #include "common.h" - #include "../auth/auth.h" -@@ -207,8 +208,11 @@ static int gip_gamepad_init_input(struct gip_gamepad *gamepad) - return 0; - - err_delete_timer: -+#if LINUX_VERSION_CODE >= KERNEL_VERSION(6,15,0) -+ timer_delete_sync(&gamepad->rumble.timer); -+#else - del_timer_sync(&gamepad->rumble.timer); -- -+#endif - return err; - } - -@@ -335,7 +339,11 @@ static void gip_gamepad_remove(struct gip_client *client) - { - struct gip_gamepad *gamepad = dev_get_drvdata(&client->dev); - -+#if LINUX_VERSION_CODE >= KERNEL_VERSION(6,15,0) -+ timer_delete_sync(&gamepad->rumble.timer); -+#else - del_timer_sync(&gamepad->rumble.timer); -+#endif - } - - static struct gip_driver gip_gamepad_driver = { diff --git a/hosts/iroha/gentoo/patches/gui-wm/gamescope/1826.diff b/hosts/iroha/gentoo/patches/gui-wm/gamescope/1826.diff new file mode 100644 index 0000000..69c85e8 --- /dev/null +++ b/hosts/iroha/gentoo/patches/gui-wm/gamescope/1826.diff @@ -0,0 +1,84 @@ +diff --git a/src/Backends/WaylandBackend.cpp b/src/Backends/WaylandBackend.cpp +index 7e68a44fb..65e35f525 100644 +--- a/src/Backends/WaylandBackend.cpp ++++ b/src/Backends/WaylandBackend.cpp +@@ -2002,24 +2002,32 @@ namespace gamescope + // Prefer opaque for composition on the Wayland backend. + + uint32_t u8BitFormat = DRM_FORMAT_INVALID; +- if ( SupportsFormat( DRM_FORMAT_XRGB8888 ) ) +- u8BitFormat = DRM_FORMAT_XRGB8888; +- else if ( SupportsFormat( DRM_FORMAT_XBGR8888 ) ) +- u8BitFormat = DRM_FORMAT_XBGR8888; +- else if ( SupportsFormat( DRM_FORMAT_ARGB8888 ) ) +- u8BitFormat = DRM_FORMAT_ARGB8888; +- else if ( SupportsFormat( DRM_FORMAT_ABGR8888 ) ) +- u8BitFormat = DRM_FORMAT_ABGR8888; ++ for (int i = 0; i < 2 && u8BitFormat == DRM_FORMAT_INVALID; i++) ++ { ++ bool invalidOnly = i == 0; ++ if ( SupportsFormat( DRM_FORMAT_XRGB8888, invalidOnly ) ) ++ u8BitFormat = DRM_FORMAT_XRGB8888; ++ else if ( SupportsFormat( DRM_FORMAT_XBGR8888, invalidOnly ) ) ++ u8BitFormat = DRM_FORMAT_XBGR8888; ++ else if ( SupportsFormat( DRM_FORMAT_ARGB8888, invalidOnly ) ) ++ u8BitFormat = DRM_FORMAT_ARGB8888; ++ else if ( SupportsFormat( DRM_FORMAT_ABGR8888, invalidOnly ) ) ++ u8BitFormat = DRM_FORMAT_ABGR8888; ++ } + + uint32_t u10BitFormat = DRM_FORMAT_INVALID; +- if ( SupportsFormat( DRM_FORMAT_XBGR2101010 ) ) +- u10BitFormat = DRM_FORMAT_XBGR2101010; +- else if ( SupportsFormat( DRM_FORMAT_XRGB2101010 ) ) +- u10BitFormat = DRM_FORMAT_XRGB2101010; +- else if ( SupportsFormat( DRM_FORMAT_ABGR2101010 ) ) +- u10BitFormat = DRM_FORMAT_ABGR2101010; +- else if ( SupportsFormat( DRM_FORMAT_ARGB2101010 ) ) +- u10BitFormat = DRM_FORMAT_ARGB2101010; ++ for (int i = 0; i < 2 && u10BitFormat == DRM_FORMAT_INVALID; i++) ++ { ++ bool invalidOnly = i == 0; ++ if ( SupportsFormat( DRM_FORMAT_XBGR2101010, invalidOnly ) ) ++ u10BitFormat = DRM_FORMAT_XBGR2101010; ++ else if ( SupportsFormat( DRM_FORMAT_XRGB2101010, invalidOnly ) ) ++ u10BitFormat = DRM_FORMAT_XRGB2101010; ++ else if ( SupportsFormat( DRM_FORMAT_ABGR2101010, invalidOnly ) ) ++ u10BitFormat = DRM_FORMAT_ABGR2101010; ++ else if ( SupportsFormat( DRM_FORMAT_ARGB2101010, invalidOnly ) ) ++ u10BitFormat = DRM_FORMAT_ARGB2101010; ++ } + + assert( u8BitFormat != DRM_FORMAT_INVALID ); + +diff --git a/src/backend.h b/src/backend.h +index 29219dbc8..2767546cd 100644 +--- a/src/backend.h ++++ b/src/backend.h +@@ -309,9 +309,11 @@ namespace gamescope + + virtual bool UsesModifiers() const = 0; + virtual std::span<const uint64_t> GetSupportedModifiers( uint32_t uDrmFormat ) const = 0; +- inline bool SupportsFormat( uint32_t uDrmFormat ) const ++ inline bool SupportsFormat( uint32_t uDrmFormat, bool invalidOnly ) const + { +- return Algorithm::Contains( this->GetSupportedModifiers( uDrmFormat ), DRM_FORMAT_MOD_INVALID ); ++ if ( invalidOnly ) ++ return Algorithm::Contains( this->GetSupportedModifiers( uDrmFormat ), DRM_FORMAT_MOD_INVALID ); ++ return !this->GetSupportedModifiers( uDrmFormat ).empty(); + } + + virtual IBackendConnector *GetCurrentConnector() = 0; +diff --git a/src/rendervulkan.cpp b/src/rendervulkan.cpp +index b8412b8fd..f41ef4c9b 100644 +--- a/src/rendervulkan.cpp ++++ b/src/rendervulkan.cpp +@@ -2814,7 +2814,7 @@ bool vulkan_init_format(VkFormat format, uint32_t drmFormat) + } + else + { +- if ( GetBackend()->UsesModifiers() && !GetBackend()->SupportsFormat( drmFormat ) ) ++ if ( GetBackend()->UsesModifiers() && !GetBackend()->SupportsFormat( drmFormat, true ) ) + return false; + + wlr_drm_format_set_add( &sampledDRMFormats, drmFormat, DRM_FORMAT_MOD_INVALID ); diff --git a/hosts/iroha/gentoo/patches/gui-wm/gamescope/740_rebase.diff b/hosts/iroha/gentoo/patches/gui-wm/gamescope/740_rebase.diff new file mode 100644 index 0000000..79a87eb --- /dev/null +++ b/hosts/iroha/gentoo/patches/gui-wm/gamescope/740_rebase.diff @@ -0,0 +1,693 @@ +diff --git a/src/Backends/DRMBackend.cpp b/src/Backends/DRMBackend.cpp +index 1ec2699..26c0afc 100644 +--- a/src/Backends/DRMBackend.cpp ++++ b/src/Backends/DRMBackend.cpp +@@ -3424,6 +3424,7 @@ namespace gamescope + bNeedsFullComposite |= bWasFirstFrame; + bNeedsFullComposite |= pFrameInfo->useFSRLayer0; + bNeedsFullComposite |= pFrameInfo->useNISLayer0; ++ bNeedsFullComposite |= pFrameInfo->useBICUBICLayer0; + bNeedsFullComposite |= pFrameInfo->blurLayer0; + bNeedsFullComposite |= bNeedsCompositeFromFilter; + bNeedsFullComposite |= !k_bUseCursorPlane && bDrewCursor; +diff --git a/src/Backends/OpenVRBackend.cpp b/src/Backends/OpenVRBackend.cpp +index 1f0e822..6756835 100644 +--- a/src/Backends/OpenVRBackend.cpp ++++ b/src/Backends/OpenVRBackend.cpp +@@ -1431,6 +1431,7 @@ namespace gamescope + bNeedsFullComposite |= cv_composite_force; + bNeedsFullComposite |= pFrameInfo->useFSRLayer0; + bNeedsFullComposite |= pFrameInfo->useNISLayer0; ++ bNeedsFullComposite |= pFrameInfo->useBICUBICLayer0; + bNeedsFullComposite |= pFrameInfo->blurLayer0; + bNeedsFullComposite |= bNeedsCompositeFromFilter; + bNeedsFullComposite |= g_bColorSliderInUse; +diff --git a/src/Backends/SDLBackend.cpp b/src/Backends/SDLBackend.cpp +index 2bb8fb0..87b1bed 100644 +--- a/src/Backends/SDLBackend.cpp ++++ b/src/Backends/SDLBackend.cpp +@@ -736,7 +736,7 @@ namespace gamescope + if ( event.key.keysym.mod & KMOD_LGUI ) + { + uint32_t key = SDLScancodeToLinuxKey( event.key.keysym.scancode ); +- const uint32_t shortcutKeys[] = {KEY_F, KEY_N, KEY_B, KEY_U, KEY_Y, KEY_I, KEY_O, KEY_S, KEY_G}; ++ const uint32_t shortcutKeys[] = {KEY_F, KEY_N, KEY_B, KEY_K, KEY_U, KEY_Y, KEY_I, KEY_O, KEY_S, KEY_G}; + const bool isShortcutKey = std::find(std::begin(shortcutKeys), std::end(shortcutKeys), key) != std::end(shortcutKeys); + if ( isShortcutKey ) + { +@@ -764,6 +764,10 @@ namespace gamescope + case KEY_B: + g_wantedUpscaleFilter = GamescopeUpscaleFilter::LINEAR; + break; ++ case KEY_K: ++ g_wantedDownscaleFilter = (g_wantedDownscaleFilter == GamescopeDownscaleFilter::BICUBIC) ? ++ GamescopeDownscaleFilter::LINEAR : GamescopeDownscaleFilter::BICUBIC; ++ break; + case KEY_U: + g_wantedUpscaleFilter = (g_wantedUpscaleFilter == GamescopeUpscaleFilter::FSR) ? + GamescopeUpscaleFilter::LINEAR : GamescopeUpscaleFilter::FSR; +diff --git a/src/Backends/WaylandBackend.cpp b/src/Backends/WaylandBackend.cpp +index 664ed0e..d942cd6 100644 +--- a/src/Backends/WaylandBackend.cpp ++++ b/src/Backends/WaylandBackend.cpp +@@ -1022,6 +1022,7 @@ namespace gamescope + bNeedsFullComposite |= cv_composite_force; + bNeedsFullComposite |= pFrameInfo->useFSRLayer0; + bNeedsFullComposite |= pFrameInfo->useNISLayer0; ++ bNeedsFullComposite |= pFrameInfo->useBICUBICLayer0; + bNeedsFullComposite |= pFrameInfo->blurLayer0; + bNeedsFullComposite |= bNeedsCompositeFromFilter; + bNeedsFullComposite |= g_bColorSliderInUse; +@@ -2877,6 +2878,16 @@ namespace gamescope + return; + } + ++ case KEY_K: ++ { ++ if ( !bPressed ) ++ { ++ g_wantedDownscaleFilter = (g_wantedDownscaleFilter == GamescopeDownscaleFilter::BICUBIC) ? ++ GamescopeDownscaleFilter::LINEAR : GamescopeDownscaleFilter::BICUBIC; ++ } ++ return; ++ } ++ + case KEY_Y: + { + if ( !bPressed ) +diff --git a/src/main.cpp b/src/main.cpp +index cdb35c3..78e072b 100644 +--- a/src/main.cpp ++++ b/src/main.cpp +@@ -7,6 +7,7 @@ + #include <mutex> + #include <vector> + #include <cstring> ++#include <sstream> + #include <string> + #if defined(__linux__) + #include <sys/capability.h> +@@ -297,11 +298,14 @@ bool g_bGrabbed = false; + float g_mouseSensitivity = 1.0; + + GamescopeUpscaleFilter g_upscaleFilter = GamescopeUpscaleFilter::LINEAR; ++GamescopeDownscaleFilter g_downscaleFilter = GamescopeDownscaleFilter::LINEAR; + GamescopeUpscaleScaler g_upscaleScaler = GamescopeUpscaleScaler::AUTO; + + GamescopeUpscaleFilter g_wantedUpscaleFilter = GamescopeUpscaleFilter::LINEAR; ++GamescopeDownscaleFilter g_wantedDownscaleFilter = GamescopeDownscaleFilter::LINEAR; + GamescopeUpscaleScaler g_wantedUpscaleScaler = GamescopeUpscaleScaler::AUTO; + int g_upscaleFilterSharpness = 2; ++GamescopeBicubicParams g_bicubicParams; + + gamescope::GamescopeModeGeneration g_eGamescopeModeGeneration = gamescope::GAMESCOPE_MODE_GENERATE_CVT; + +@@ -406,6 +410,54 @@ static enum GamescopeUpscaleFilter parse_upscaler_filter(const char *str) + } + } + ++static enum GamescopeDownscaleFilter parse_downscaler_filter(const char *str) ++{ ++ std::string_view arg{str}; ++ ++ // If the string is just 'bicubic' use default values ++ if ( arg == "bicubic" ) { ++ return GamescopeDownscaleFilter::BICUBIC; ++ } ++ ++ // Arguments start after ':' ++ if ( auto search = arg.find(':'); search == std::string::npos ) { ++ fprintf( stderr, "gamescope: invalid argument for --filter=bicubic:float,float\n" ); ++ exit(1); ++ } else { ++ arg = std::string_view(arg.data() + search + 1); ++ } ++ ++ // Push arguments to stream ++ std::stringstream ss; ++ ss << arg; ++ ++ // Validate arguments from stream ++ double b, c; ++ char comma; ++ if ((ss >> b >> comma >> c) && (comma == ',')) { ++ // clamp values ++ b = std::clamp(b, 0.0, 1.0); ++ c = std::clamp(c, 0.0, 1.0); ++ // Ovewrite default global parameters ++ g_bicubicParams.b = b; ++ g_bicubicParams.c = c; ++ // Set downscaler filters ++ return GamescopeDownscaleFilter::BICUBIC; ++ } ++ ++ fprintf( stderr, "gamescope: invalid value for --filter\n" ); ++ exit(1); ++} ++ ++static void parse_filter(const char *str) ++{ ++ if (std::string_view{str}.starts_with("bicubic")) { ++ g_wantedDownscaleFilter = parse_downscaler_filter(str); ++ } else { ++ g_wantedUpscaleFilter = parse_upscaler_filter(str); ++ } ++} ++ + static enum gamescope::GamescopeBackend parse_backend_name(const char *str) + { + if (strcmp(str, "auto") == 0) { +@@ -736,7 +788,7 @@ int main(int argc, char **argv) + g_wantedUpscaleScaler = parse_upscaler_scaler(optarg); + break; + case 'F': +- g_wantedUpscaleFilter = parse_upscaler_filter(optarg); ++ parse_filter(optarg); + break; + case 'b': + g_bBorderlessOutputWindow = true; +diff --git a/src/main.hpp b/src/main.hpp +index 2e6fb83..f8cc030 100644 +--- a/src/main.hpp ++++ b/src/main.hpp +@@ -40,6 +40,18 @@ enum class GamescopeUpscaleFilter : uint32_t + FROM_VIEW = 0xF, // internal + }; + ++enum class GamescopeDownscaleFilter : uint32_t ++{ ++ LINEAR = 0, ++ BICUBIC, ++}; ++ ++struct GamescopeBicubicParams ++{ ++ float b = 0.3f; ++ float c = 0.3f; ++}; ++ + static constexpr bool DoesHardwareSupportUpscaleFilter( GamescopeUpscaleFilter eFilter ) + { + // Could do nearest someday... AMDGPU DC supports custom tap placement to an extent. +@@ -57,10 +69,13 @@ enum class GamescopeUpscaleScaler : uint32_t + }; + + extern GamescopeUpscaleFilter g_upscaleFilter; ++extern GamescopeDownscaleFilter g_downscaleFilter; + extern GamescopeUpscaleScaler g_upscaleScaler; + extern GamescopeUpscaleFilter g_wantedUpscaleFilter; ++extern GamescopeDownscaleFilter g_wantedDownscaleFilter; + extern GamescopeUpscaleScaler g_wantedUpscaleScaler; + extern int g_upscaleFilterSharpness; ++extern GamescopeBicubicParams g_bicubicParams; + + extern bool g_bBorderlessOutputWindow; + +diff --git a/src/meson.build b/src/meson.build +index a3dfdab..5d3019f 100644 +--- a/src/meson.build ++++ b/src/meson.build +@@ -66,6 +66,7 @@ shader_src = [ + 'shaders/cs_composite_rcas.comp', + 'shaders/cs_easu.comp', + 'shaders/cs_easu_fp16.comp', ++ 'shaders/cs_bicubic.comp', + 'shaders/cs_gaussian_blur_horizontal.comp', + 'shaders/cs_nis.comp', + 'shaders/cs_nis_fp16.comp', +diff --git a/src/rendervulkan.cpp b/src/rendervulkan.cpp +index f79d26e..cc7edbb 100644 +--- a/src/rendervulkan.cpp ++++ b/src/rendervulkan.cpp +@@ -44,6 +44,7 @@ + #include "cs_composite_rcas.h" + #include "cs_easu.h" + #include "cs_easu_fp16.h" ++#include "cs_bicubic.h" + #include "cs_gaussian_blur_horizontal.h" + #include "cs_nis.h" + #include "cs_nis_fp16.h" +@@ -52,6 +53,7 @@ + #define A_CPU + #include "shaders/ffx_a.h" + #include "shaders/ffx_fsr1.h" ++#include "shaders/bicubic.h" + + #include "reshade_effect_manager.hpp" + +@@ -912,6 +914,7 @@ bool CVulkanDevice::createShaders() + SHADER(BLUR_COND, cs_composite_blur_cond); + SHADER(BLUR_FIRST_PASS, cs_gaussian_blur_horizontal); + SHADER(RCAS, cs_composite_rcas); ++ SHADER(BICUBIC, cs_bicubic); + if (m_bSupportsFp16) + { + SHADER(EASU, cs_easu_fp16); +@@ -1151,6 +1154,7 @@ void CVulkanDevice::compileAllPipelines() + SHADER(BLUR_FIRST_PASS, 1, 2, 1); + SHADER(RCAS, k_nMaxLayers, k_nMaxYcbcrMask_ToPreCompile, 1); + SHADER(EASU, 1, 1, 1); ++ SHADER(BICUBIC, 1, 1, 1); + SHADER(NIS, 1, 1, 1); + SHADER(RGB_TO_NV12, 1, 1, 1); + #undef SHADER +@@ -3732,6 +3736,17 @@ struct EasuPushData_t + } + }; + ++struct BicubicPushData_t ++{ ++ uvec4_t Const0; ++ uvec4_t Const1; ++ ++ BicubicPushData_t(float B, float C, uint32_t inputX, uint32_t inputY, uint32_t tempX, uint32_t tempY, uint32_t winX, uint32_t winY) ++ { ++ BicubicCon(&Const0.x, &Const1.x, B*10, C*10, inputX, inputY, tempX, tempY, winX, winY); ++ } ++}; ++ + struct RcasPushData_t + { + uvec2_t u_layer0Offset; +@@ -3950,7 +3965,51 @@ std::optional<uint64_t> vulkan_composite( struct FrameInfo_t *frameInfo, gamesco + for (uint32_t i = 0; i < EOTF_Count; i++) + cmdBuffer->bindColorMgmtLuts(i, frameInfo->shaperLut[i], frameInfo->lut3D[i]); + +- if ( frameInfo->useFSRLayer0 ) ++ if ( frameInfo->useBICUBICLayer0 ) ++ { ++ uint32_t inputX = frameInfo->layers[0].tex->width(); ++ uint32_t inputY = frameInfo->layers[0].tex->height(); ++ ++ uint32_t tempX = frameInfo->layers[0].integerWidth(); ++ uint32_t tempY = frameInfo->layers[0].integerHeight(); ++ ++ update_tmp_images(tempX, tempY); ++ ++ cmdBuffer->bindPipeline( g_device.pipeline(SHADER_TYPE_BICUBIC, frameInfo->layerCount, frameInfo->ycbcrMask())); ++ cmdBuffer->bindTarget(g_output.tmpOutput); ++ cmdBuffer->bindTexture(0, frameInfo->layers[0].tex); ++ cmdBuffer->setTextureSrgb(0, true); ++ cmdBuffer->setSamplerUnnormalized(0, false); ++ cmdBuffer->setSamplerNearest(0, false); ++ cmdBuffer->uploadConstants<BicubicPushData_t>(g_bicubicParams.b ++ , g_bicubicParams.c ++ , inputX ++ , inputY ++ , tempX ++ , tempY ++ , currentOutputWidth ++ , currentOutputHeight ++ ); ++ ++ int pixelsPerGroup = 16; ++ ++ cmdBuffer->dispatch(div_roundup(tempX, pixelsPerGroup), div_roundup(tempY, pixelsPerGroup)); ++ ++ struct FrameInfo_t bicFrameInfo = *frameInfo; ++ bicFrameInfo.layers[0].tex = g_output.tmpOutput; ++ bicFrameInfo.layers[0].scale.x = 1.0f; ++ bicFrameInfo.layers[0].scale.y = 1.0f; ++ ++ cmdBuffer->bindPipeline( g_device.pipeline(SHADER_TYPE_BLIT, bicFrameInfo.layerCount, bicFrameInfo.ycbcrMask())); ++ bind_all_layers(cmdBuffer.get(), &bicFrameInfo); ++ cmdBuffer->bindTarget(compositeImage); ++ cmdBuffer->uploadConstants<BlitPushData_t>(&bicFrameInfo); ++ ++ pixelsPerGroup = 8; ++ ++ cmdBuffer->dispatch(div_roundup(currentOutputWidth, pixelsPerGroup), div_roundup(currentOutputHeight, pixelsPerGroup)); ++ } ++ else if ( frameInfo->useFSRLayer0 ) + { + uint32_t inputX = frameInfo->layers[0].tex->width(); + uint32_t inputY = frameInfo->layers[0].tex->height(); +diff --git a/src/rendervulkan.hpp b/src/rendervulkan.hpp +index 63cc602..4092e82 100644 +--- a/src/rendervulkan.hpp ++++ b/src/rendervulkan.hpp +@@ -281,6 +281,7 @@ struct FrameInfo_t + { + bool useFSRLayer0; + bool useNISLayer0; ++ bool useBICUBICLayer0; + bool bFadingOut; + BlurMode blurLayer0; + int blurRadius; +@@ -556,6 +557,7 @@ enum ShaderType { + SHADER_TYPE_EASU, + SHADER_TYPE_RCAS, + SHADER_TYPE_NIS, ++ SHADER_TYPE_BICUBIC, + SHADER_TYPE_RGB_TO_NV12, + + SHADER_TYPE_COUNT +diff --git a/src/shaders/bicubic.h b/src/shaders/bicubic.h +new file mode 100644 +index 0000000..8117e87 +--- /dev/null ++++ b/src/shaders/bicubic.h +@@ -0,0 +1,44 @@ ++//_____________________________________________________________/\_______________________________________________________________ ++//============================================================================================================================== ++// ++// ++// BICUBIC IMAGE SCALING ++// ++// ++//------------------------------------------------------------------------------------------------------------------------------ ++//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// ++//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// ++//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// ++//_____________________________________________________________/\_______________________________________________________________ ++//============================================================================================================================== ++// CONSTANT SETUP ++//============================================================================================================================== ++// Call to setup required constant values (works on CPU or GPU). ++A_STATIC void BicubicCon( ++outAU4 con0, ++outAU4 con1, ++// Configurable parameters ++AU1 B, ++AU1 C, ++// This the rendered image resolution ++AF1 inputRenderedSizeX, ++AF1 inputRenderedSizeY, ++// This is the resolution of the resource containing the input image (useful for dynamic resolution) ++AF1 inputCurrentSizeX, ++AF1 inputCurrentSizeY, ++// This is the window width / height ++AF1 outputTargetSizeX, ++AF1 outputTargetSizeY) ++{ ++ // Input/Output size information ++ con0[0]=AU1_AF1(inputRenderedSizeX); ++ con0[1]=AU1_AF1(inputRenderedSizeY); ++ con0[2]=AU1_AF1(inputCurrentSizeX); ++ con0[3]=AU1_AF1(inputCurrentSizeY); ++ ++ // Viewport pixel position to normalized image space. ++ con1[0]=AU1_AF1(outputTargetSizeX); ++ con1[1]=AU1_AF1(outputTargetSizeY); ++ con1[2]=B; ++ con1[3]=C; ++} +diff --git a/src/shaders/cs_bicubic.comp b/src/shaders/cs_bicubic.comp +new file mode 100644 +index 0000000..2b6dfb8 +--- /dev/null ++++ b/src/shaders/cs_bicubic.comp +@@ -0,0 +1,177 @@ ++// References ++// https://www.codeproject.com/Articles/236394/Bi-Cubic-and-Bi-Linear-Interpolation-with-GLSL ++// https://stackoverflow.com/questions/13501081/efficient-bicubic-filtering-code-in-glsl ++// https://web.archive.org/web/20180927181721/http://www.java-gaming.org/index.php?topic=35123.0 ++// https://gist.github.com/TheRealMJP/c83b8c0f46b63f3a88a5986f4fa982b1 ++ ++#version 460 ++ ++#extension GL_GOOGLE_include_directive : require ++#extension GL_EXT_shader_explicit_arithmetic_types_float16 : require ++#extension GL_EXT_scalar_block_layout : require ++ ++#include "descriptor_set.h" ++ ++layout( ++ local_size_x = 64, ++ local_size_y = 1, ++ local_size_z = 1) in; ++ ++// Push constant is a mechanism in modern OpenGL that allows passing small amounts of frequently ++// updated data to the shader without needing to bind a buffer ++layout(binding = 0, scalar) ++uniform layers_t { ++ uvec4 c0, c1; ++}; ++ ++#define A_GPU 1 ++#define A_GLSL 1 ++#define A_HALF 1 ++#include "ffx_a.h" ++#include "bicubic.h" ++ ++// The Mitchell–Netravali filters or BC-splines ++// https://en.wikipedia.org/wiki/Mitchell%E2%80%93Netravali_filters ++// Conditionals are slow in GPU code, so to represent 0 <= f < 1 and 1 <= f < 2 ++// the P(d) form shown in the wikipedia page is used ++vec4 mitchellNetravaliWeights(float f, float B, float C) ++{ ++ float w0 = ((12.0 - 9.0 * B - 6.0 * C) * pow(f, 3.0)) + ++ ((-18.0 + 12.0 * B + 6.0 * C) * pow(f, 2.0)) + ++ (6.0 - 2.0 * B); ++ ++ float w1 = ((-B - 6.0 * C) * pow(f - 1.0, 3.0)) + ++ ((6.0 * B + 30.0 * C) * pow(f - 1.0, 2.0)) + ++ ((-12.0 * B - 48.0 * C) * (f - 1.0)) + ++ (8.0 * B + 24.0 * C); ++ ++ float w2 = ((12.0 - 9.0 * B - 6.0 * C) * pow(1.0 - f, 3.0)) + ++ ((-18.0 + 12.0 * B + 6.0 * C) * pow(1.0 - f, 2.0)) + ++ (6.0 - 2.0 * B); ++ ++ float w3 = ((-B - 6.0 * C) * pow(2.0 - f, 3.0)) + ++ ((6.0 * B + 30.0 * C) * pow(2.0 - f, 2.0)) + ++ ((-12.0 * B - 48.0 * C) * (2.0 - f)) + ++ (8.0 * B + 24.0 * C); ++ ++ return vec4(w0, w1, w2, w3); ++} ++ ++// https://stackoverflow.com/questions/13501081/efficient-bicubic-filtering-code-in-glsl ++// https://web.archive.org/web/20180927181721/http://www.java-gaming.org/index.php?topic=35123.0 ++// This is an efficient method to implement bicubic filtering, it takes ++// advantage of the fact that the bilinear approach gives the weighted average ++// of a 2x2 area. ++vec4 textureBicubic(sampler2D splr, vec2 texCoords) ++{ ++ vec2 texSize = textureSize(splr, 0); ++ vec2 invTexSize = 1.0 / texSize; ++ ++ // Converts normalized coordinates into pixel-space coordinate ++ // Example: If texCoords is (0.5, 0.5), and the texture size is (1920, 1080), the result will be ++ // (960, 540)—the center of the texture in pixel space. ++ // Subtracting 0.5 ensures that you're sampling from the center of the texel rather than its corner ++ // Example: Assume we have a 3x3 texture and texCoords = (0.5, 0.5): ++ // [0,0][1,0][2,0] ++ // [0,1][1,1][2,1] ++ // [0,2][1,2][2,2] ++ // texCoords * texSize - 0.5 maps to (1.5, 1.5), which is between (1,1) and (2,2), then ++ // subtracts 0.5 to move it to (1.0, 1.0)—the center of the texel ++ texCoords = texCoords * texSize - 0.5; ++ ++ // Get B and C that were pushed from the user input (or default values) ++ float B = c1[2] / 10.0f; ++ float C = c1[3] / 10.0f; ++ ++ // Get the fractional part of the coordinates ++ // They are used in Mitchell Netravali's strategy to calculate the interpolation weights, ++ // i.e., how much influence the neighboring vertices have on the final pixel value ++ vec2 fxy = fract(texCoords); ++ texCoords -= fxy; ++ ++ // Calculate bicubic weights ++ // These weights represent how much influence each neighboring texel in the 4x4 grid will have ++ // on the final interpolated pixel value ++ vec4 xweights = mitchellNetravaliWeights(fxy.x, B, C); ++ vec4 yweights = mitchellNetravaliWeights(fxy.y, B, C); ++ ++ // Modify the current texture coordinates to have an offset in texels for each coordinate ++ // E.g. texCoords + vec(-1.0, 0.0) is a texel to the left ++ // texCoords + vec(1.0, 0.0) is a texel to the right ++ // texCoords + vec(0.0, 1.0) is a texel downwards ++ // texCoords + vec(0.0, -1.0) is a texel upwards ++ vec4 offsetTexels = texCoords.xxyy; ++ offsetTexels += vec2 (-1.0, +1.0).xyxy; ++ // Normalize weights to range between (0,1) ++ // vec4 sumWeights = vec4(xweights.xz + xweights.yw, yweights.xz + yweights.yw); ++ // vec4 normalizedWeights = vec4 (xweights.yw, yweights.yw) / sumWeights; ++ vec4 sumWeights = vec4(xweights.x + xweights.y, xweights.z + xweights.w, yweights.x + yweights.y, yweights.z + yweights.w); ++ vec4 normalizedWeights = vec4 (xweights.y, xweights.w, yweights.y, yweights.w) / sumWeights; ++ // Use the weights to influence the sampling position inside each texel ++ // Each texel has a size from (0,1) ++ vec4 offsetSampler = offsetTexels + normalizedWeights; ++ // Go back to normalized space ++ offsetSampler *= invTexSize.xxyy; ++ // Perform the sampling ++ vec4 sample0 = texture(splr, offsetSampler.xz); ++ vec4 sample1 = texture(splr, offsetSampler.yz); ++ vec4 sample2 = texture(splr, offsetSampler.xw); ++ vec4 sample3 = texture(splr, offsetSampler.yw); ++ ++ // Now we perform linear interpolation in the selected points ++ // The mix(a, b, t) function in GLSL performs linear interpolation between a and b based on the ++ // parameter t, t is between 0 and 1 ++ // https://registry.khronos.org/OpenGL-Refpages/gl4/html/mix.xhtml ++ ++ // Here we want to normalize sx and sy to between 0 and 1 (t value) ++ float sx = sumWeights.x / (sumWeights.x + sumWeights.y); ++ float sy = sumWeights.z / (sumWeights.z + sumWeights.w); ++ ++ return mix( ++ mix(sample3, sample2, sx), mix(sample1, sample0, sx) ++ , sy); ++} ++ ++void bicPass(uvec2 pos) ++{ ++ // Retrieve pushed values ++ AF2 inputRenderedSize = AF2_AU2(c0.xy); ++ AF2 inputCurrentSize = AF2_AU2(c0.zw); ++ AF2 outputTargetSize = AF2_AU2(c1.xy); ++ ++ // ARcpF1(x) == 1.0 / x ++ // scaleFactor is the division between the rendered image and the size it should have at the end ++ // E.g.: Rendered 1920x1080, window size is 960x540, then scaleFactor is 2x2 ++ AF2 scaleFactor = inputRenderedSize * vec2(ARcpF1(inputCurrentSize.x), ARcpF1(inputCurrentSize.y)); ++ ++ // The parameter pos of this function is used to iterate over the output image (e.g. 960x540) ++ // The position of the processed pixel should be taken from the rendered image (e.g. 1920x1080) ++ // 10x10 in the output, corresponds to 20x20 in the original image ++ AF2 positionPixel=AF2(pos)*scaleFactor; ++ ++ // Normalize the image space to be between [0,1] ++ positionPixel=positionPixel*vec2(ARcpF1(inputRenderedSize.x),ARcpF1(inputRenderedSize.y)); ++ ++ // Apply the bicubic algorithm in the normalized pixel position ++ vec4 bicPass = textureBicubic(s_samplers[0], positionPixel); ++ ++ imageStore(dst, ivec2(pos), bicPass); ++} ++ ++ ++void main() ++{ ++ // AMD recommends to use this swizzle and to process 4 pixel per invocation ++ // for better cache utilisation ++ uvec2 pos = ARmp8x8(gl_LocalInvocationID.x) + uvec2(gl_WorkGroupID.x << 4u, gl_WorkGroupID.y << 4u); ++ ++ bicPass(pos); ++ pos.x += 8u; ++ bicPass(pos); ++ pos.y += 8u; ++ bicPass(pos); ++ pos.x -= 8u; ++ bicPass(pos); ++} ++ ++/* vim: set expandtab ft=cpp fdm=marker ts=4 sw=4 tw=100 et :*/ +diff --git a/src/shaders/descriptor_set.h b/src/shaders/descriptor_set.h +index f2b8527..64cc1c9 100644 +--- a/src/shaders/descriptor_set.h ++++ b/src/shaders/descriptor_set.h +@@ -21,6 +21,7 @@ const int filter_nearest = 1; + const int filter_fsr = 2; + const int filter_nis = 3; + const int filter_pixel = 4; ++const int filter_bicubic = 5; + const int filter_from_view = 255; + + const int EOTF_Gamma22 = 0; +diff --git a/src/steamcompmgr.cpp b/src/steamcompmgr.cpp +index c1d49fd..44cb223 100644 +--- a/src/steamcompmgr.cpp ++++ b/src/steamcompmgr.cpp +@@ -1015,6 +1015,7 @@ gamescope::ConCommand cc_debug_set_fps_limit( "debug_set_fps_limit", "Set refres + static int g_nRuntimeInfoFd = -1; + + bool g_bFSRActive = false; ++bool g_bBicubicActive = false; + + BlurMode g_BlurMode = BLUR_MODE_OFF; + BlurMode g_BlurModeOld = BLUR_MODE_OFF; +@@ -2555,6 +2556,8 @@ paint_all( global_focus_t *pFocus, bool async ) + paint_window(w, w, &frameInfo, pFocus->cursor, PaintWindowFlag::BasePlane | PaintWindowFlag::DrawBorders, 1.0f, override); + + bool needsScaling = frameInfo.layers[0].scale.x < 0.999f && frameInfo.layers[0].scale.y < 0.999f; ++ bool needsDownScaling = true; ++ frameInfo.useBICUBICLayer0 = g_downscaleFilter == GamescopeDownscaleFilter::BICUBIC && needsDownScaling; + frameInfo.useFSRLayer0 = g_upscaleFilter == GamescopeUpscaleFilter::FSR && needsScaling; + frameInfo.useNISLayer0 = g_upscaleFilter == GamescopeUpscaleFilter::NIS && needsScaling; + } +@@ -2696,6 +2699,7 @@ paint_all( global_focus_t *pFocus, bool async ) + } + + frameInfo.useFSRLayer0 = false; ++ frameInfo.useBICUBICLayer0 = false; + frameInfo.useNISLayer0 = false; + } + +@@ -5761,6 +5765,9 @@ handle_property_notify(xwayland_ctx_t *ctx, XPropertyEvent *ev) + g_wantedUpscaleScaler = GamescopeUpscaleScaler::AUTO; + g_wantedUpscaleFilter = GamescopeUpscaleFilter::NIS; + break; ++ case 5: ++ g_wantedDownscaleFilter = GamescopeDownscaleFilter::BICUBIC; ++ break; + } + hasRepaint = true; + } +@@ -7391,6 +7398,7 @@ void init_xwayland_ctx(uint32_t serverId, gamescope_xwayland_server_t *xwayland_ + ctx->atoms.gamescopeLowLatency = XInternAtom( ctx->dpy, "GAMESCOPE_LOW_LATENCY", false ); + + ctx->atoms.gamescopeFSRFeedback = XInternAtom( ctx->dpy, "GAMESCOPE_FSR_FEEDBACK", false ); ++ ctx->atoms.gamescopeBicubicFeedback = XInternAtom( ctx->dpy, "GAMESCOPE_BICUBIC_FEEDBACK", false ); + + ctx->atoms.gamescopeBlurMode = XInternAtom( ctx->dpy, "GAMESCOPE_BLUR_MODE", false ); + ctx->atoms.gamescopeBlurRadius = XInternAtom( ctx->dpy, "GAMESCOPE_BLUR_RADIUS", false ); +@@ -7645,6 +7653,7 @@ extern int g_nPreferredOutputWidth; + extern int g_nPreferredOutputHeight; + + static bool g_bWasFSRActive = false; ++static bool g_bWasBicubicActive = false; + + bool g_bAppWantsHDRCached = false; + +@@ -8091,6 +8100,16 @@ steamcompmgr_main(int argc, char **argv) + flush_root = true; + } + ++ if ( g_bBicubicActive != g_bWasBicubicActive ) ++ { ++ uint32_t active = g_bBicubicActive ? 1 : 0; ++ XChangeProperty( root_ctx->dpy, root_ctx->root, root_ctx->atoms.gamescopeBicubicFeedback, XA_CARDINAL, 32, PropModeReplace, ++ (unsigned char *)&active, 1 ); ++ ++ g_bWasBicubicActive = g_bBicubicActive; ++ flush_root = true; ++ } ++ + static gamescope::VirtualConnectorStrategy s_eLastVirtualConnectorStrategy = gamescope::cv_backend_virtual_connector_strategy; + gamescope::VirtualConnectorStrategy eVirtualConnectorStrategy = gamescope::cv_backend_virtual_connector_strategy; + +@@ -8439,6 +8458,7 @@ steamcompmgr_main(int argc, char **argv) + g_bSteamIsActiveWindow = false; + g_upscaleScaler = g_wantedUpscaleScaler; + g_upscaleFilter = g_wantedUpscaleFilter; ++ g_downscaleFilter = g_wantedDownscaleFilter; + } + + // If we're in the middle of a fade, then keep us +diff --git a/src/steamcompmgr.hpp b/src/steamcompmgr.hpp +index 98e9272..ea7de13 100644 +--- a/src/steamcompmgr.hpp ++++ b/src/steamcompmgr.hpp +@@ -129,6 +129,7 @@ extern float focusedWindowOffsetX; + extern float focusedWindowOffsetY; + + extern bool g_bFSRActive; ++extern bool g_bBicubicActive; + + extern uint32_t inputCounter; + extern uint64_t g_lastWinSeq; +diff --git a/src/xwayland_ctx.hpp b/src/xwayland_ctx.hpp +index df2af70..e212a11 100644 +--- a/src/xwayland_ctx.hpp ++++ b/src/xwayland_ctx.hpp +@@ -164,6 +164,7 @@ struct xwayland_ctx_t final : public gamescope::IWaitable + Atom gamescopeLowLatency; + + Atom gamescopeFSRFeedback; ++ Atom gamescopeBicubicFeedback; + + Atom gamescopeBlurMode; + Atom gamescopeBlurRadius; |