add: gamescope (#1553 )

* add: gamescope * less strict buildreqs Signed-off-by: madomado <madonuko@outlook.com> * BuildRequires: pkgconfig(libliftoff) Signed-off-by: madomado <madonuko@outlook.com> --------- Signed-off-by: madomado <madonuko@outlook.com> (cherry picked from commit 50c6084c26)
2026-05-31 09:01:55 +00:00 · 2024-07-18 18:13:03 +00:00
10 changed files with 2732 additions and 0 deletions
@@ -0,0 +1,239 @@
+From ab115896be1a448bde0eb7673c26300ea4ca5040 Mon Sep 17 00:00:00 2001
+From: sharkautarch <128002472+sharkautarch@users.noreply.github.com>
+Date: Sun, 19 May 2024 20:15:36 -0400
+Subject: [PATCH 1/2] QueuePresent: canBypassXWayland(): fetch multiple xcb
+ cookies initially before waiting on any of them
+
+---
+ layer/VkLayer_FROG_gamescope_wsi.cpp |   1 +
+ layer/xcb_helpers.hpp                | 105 +++++++++++++++++++++++----
+ 2 files changed, 93 insertions(+), 13 deletions(-)
+
+diff --git a/layer/VkLayer_FROG_gamescope_wsi.cpp b/layer/VkLayer_FROG_gamescope_wsi.cpp
+index 5844c2a63..ca44849f2 100644
+--- a/layer/VkLayer_FROG_gamescope_wsi.cpp
+++ b/layer/VkLayer_FROG_gamescope_wsi.cpp
+@@ -975,6 +975,7 @@ namespace GamescopeWSILayer {
+             continue;
+           }
+ 
+          xcb::Prefetcher prefetcher(gamescopeSurface->connection, gamescopeSurface->window);
+           const bool canBypass = gamescopeSurface->canBypassXWayland();
+           if (canBypass != gamescopeSwapchain->isBypassingXWayland)
+             UpdateSwapchainResult(canBypass ? VK_SUBOPTIMAL_KHR : VK_ERROR_OUT_OF_DATE_KHR);
+diff --git a/layer/xcb_helpers.hpp b/layer/xcb_helpers.hpp
+index 8fac5635b..72d0ec092 100644
+--- a/layer/xcb_helpers.hpp
+++ b/layer/xcb_helpers.hpp
+@@ -4,22 +4,106 @@
+ #include <xcb/composite.h>
+ #include <cstdio>
+ #include <optional>
+#include <pthread.h>
+ 
+ namespace xcb {
+  inline static constinit pthread_t g_cache_tid; //incase g_cache could otherwise be accessed by one thread, while it is being deleted by another thread
+  inline static constinit struct cookie_cache_t {
+    xcb_window_t window;
+    std::tuple<xcb_get_geometry_cookie_t, xcb_query_tree_cookie_t> cached_cookies;
+    std::tuple<xcb_get_geometry_reply_t*, xcb_query_tree_reply_t*> cached_replies;
+  } g_cache = {};
+  
+  //Note: this class is currently only meant to be used within GamescopeWSILayer::VkDeviceOverrides::QueuePresentKHR:
+  struct Prefetcher {
+    explicit Prefetcher(xcb_connection_t* connection, const xcb_window_t window) {
+        g_cache = {
+            .window = window,
+            .cached_cookies = {
+                xcb_get_geometry(connection, window),
+                xcb_query_tree(connection, window)
+            }
+        };
+        g_cache_tid = pthread_self();
+    }
+ 
+    ~Prefetcher() {
+        g_cache_tid = {};
+        free(std::get<0>(g_cache.cached_replies));
+        free(std::get<1>(g_cache.cached_replies));
+        g_cache.cached_replies = {nullptr,nullptr};
+    }
+  };
+  
+   struct ReplyDeleter {
+    const bool m_bOwning = true;
+    consteval ReplyDeleter(bool bOwning = true) : m_bOwning{bOwning} {}
+     template <typename T>
+     void operator()(T* ptr) const {
+-      free(const_cast<std::remove_const_t<T>*>(ptr));
+      if (m_bOwning)
+        free(const_cast<std::remove_const_t<T>*>(ptr));
+     }
+   };
+ 
+   template <typename T>
+   using Reply = std::unique_ptr<T, ReplyDeleter>;
+  
+  template <typename Cookie_RetType, typename Reply_RetType, typename XcbConn=xcb_connection_t*, typename... Args>
+  class XcbFetch {
+    using cookie_f_ptr_t = Cookie_RetType (*)(XcbConn, Args...);
+    using reply_f_ptr_t = Reply_RetType* (*)(XcbConn, Cookie_RetType, xcb_generic_error_t**);
+    
+    const cookie_f_ptr_t m_cookieFunc;
+    const reply_f_ptr_t m_replyFunc;
+    
+    public:
+        consteval XcbFetch(cookie_f_ptr_t cookieFunc, reply_f_ptr_t replyFunc) : m_cookieFunc{cookieFunc}, m_replyFunc{replyFunc} {}
+        
+        inline Reply<Reply_RetType> operator()(XcbConn conn, auto... args) { //have to use auto for argsTwo, since otherwise there'd be a type deduction conflict
+            return Reply<Reply_RetType> { m_replyFunc(conn, m_cookieFunc(conn, args...), nullptr) };
+        }
+  };
+  
+  template <typename CookieType>
+  concept CacheableCookie = std::is_same<CookieType, xcb_get_geometry_cookie_t>::value 
+                            || std::is_same<CookieType, xcb_query_tree_cookie_t>::value;
+  
+  template <CacheableCookie Cookie_RetType, typename Reply_RetType>
+  class XcbFetch<Cookie_RetType, Reply_RetType, xcb_connection_t*, xcb_window_t> {
+    using cookie_f_ptr_t = Cookie_RetType (*)(xcb_connection_t*, xcb_window_t);
+    using reply_f_ptr_t = Reply_RetType* (*)(xcb_connection_t*, Cookie_RetType, xcb_generic_error_t**);
+    
+    const cookie_f_ptr_t m_cookieFunc;
+    const reply_f_ptr_t m_replyFunc;
+    
+    inline Reply<Reply_RetType> getCachedReply(xcb_connection_t* connection) {
+        if (std::get<Reply_RetType*>(g_cache.cached_replies) == nullptr) {
+            std::get<Reply_RetType*>(g_cache.cached_replies) = m_replyFunc(connection, std::get<Cookie_RetType>(g_cache.cached_cookies), nullptr);
+        }
+ 
+        return Reply<Reply_RetType>{std::get<Reply_RetType*>(g_cache.cached_replies), ReplyDeleter{false}}; // return 'non-owning' unique_ptr
+    }
+    
+    public:
+        consteval XcbFetch(cookie_f_ptr_t cookieFunc, reply_f_ptr_t replyFunc) : m_cookieFunc{cookieFunc}, m_replyFunc{replyFunc} {}
+        
+        inline Reply<Reply_RetType> operator()(xcb_connection_t* conn, xcb_window_t window) {
+            const bool tryCached = pthread_equal(g_cache_tid, pthread_self())
+                                   && g_cache.window == window;
+            if (!tryCached) [[unlikely]]
+                return Reply<Reply_RetType> { m_replyFunc(conn, m_cookieFunc(conn, window), nullptr) };
+            
+            auto ret = getCachedReply(conn);
+            #if !defined(NDEBUG) || NDEBUG == 0
+            if (!ret)
+                fprintf(stderr, "[Gamescope WSI] getCachedReply() failed.\n");
+            #endif
+            return ret;
+        }
+  };
+ 
+   static std::optional<xcb_atom_t> getAtom(xcb_connection_t* connection, std::string_view name) {
+-    xcb_intern_atom_cookie_t cookie = xcb_intern_atom(connection, false, name.length(), name.data());
+-    auto reply = Reply<xcb_intern_atom_reply_t>{ xcb_intern_atom_reply(connection, cookie, nullptr) };
+    auto reply = XcbFetch{xcb_intern_atom, xcb_intern_atom_reply}(connection, false, name.length(), name.data());
+     if (!reply) {
+       fprintf(stderr, "[Gamescope WSI] Failed to get xcb atom.\n");
+       return std::nullopt;
+@@ -34,8 +118,7 @@ namespace xcb {
+ 
+     xcb_screen_t* screen = xcb_setup_roots_iterator(xcb_get_setup(connection)).data;
+ 
+-    xcb_get_property_cookie_t cookie = xcb_get_property(connection, false, screen->root, atom, XCB_ATOM_CARDINAL, 0, sizeof(T) / sizeof(uint32_t));
+-    auto reply = Reply<xcb_get_property_reply_t>{ xcb_get_property_reply(connection, cookie, nullptr) };
+    auto reply = XcbFetch{xcb_get_property, xcb_get_property_reply}(connection, false, screen->root, atom, XCB_ATOM_CARDINAL, 0, sizeof(T) / sizeof(uint32_t));
+     if (!reply) {
+       fprintf(stderr, "[Gamescope WSI] Failed to read T root window property.\n");
+       return std::nullopt;
+@@ -61,8 +144,7 @@ namespace xcb {
+ 
+   static std::optional<xcb_window_t> getToplevelWindow(xcb_connection_t* connection, xcb_window_t window) {
+     for (;;) {
+-      xcb_query_tree_cookie_t cookie = xcb_query_tree(connection, window);
+-      auto reply = Reply<xcb_query_tree_reply_t>{ xcb_query_tree_reply(connection, cookie, nullptr) };
+      auto reply = XcbFetch{xcb_query_tree, xcb_query_tree_reply}(connection, window);
+ 
+       if (!reply) {
+         fprintf(stderr, "[Gamescope WSI] getToplevelWindow: xcb_query_tree failed for window 0x%x.\n", window);
+@@ -77,8 +159,7 @@ namespace xcb {
+   }
+ 
+   static std::optional<VkRect2D> getWindowRect(xcb_connection_t* connection, xcb_window_t window) {
+-    xcb_get_geometry_cookie_t cookie = xcb_get_geometry(connection, window);
+-    auto reply = Reply<xcb_get_geometry_reply_t>{ xcb_get_geometry_reply(connection, cookie, nullptr) };
+    auto reply = XcbFetch{xcb_get_geometry, xcb_get_geometry_reply}(connection, window);
+     if (!reply) {
+       fprintf(stderr, "[Gamescope WSI] getWindowRect: xcb_get_geometry failed for window 0x%x.\n", window);
+       return std::nullopt;
+@@ -112,8 +193,7 @@ namespace xcb {
+   static std::optional<VkExtent2D> getLargestObscuringChildWindowSize(xcb_connection_t* connection, xcb_window_t window) {
+     VkExtent2D largestExtent = {};
+ 
+-    xcb_query_tree_cookie_t cookie = xcb_query_tree(connection, window);
+-    auto reply = Reply<xcb_query_tree_reply_t>{ xcb_query_tree_reply(connection, cookie, nullptr) };
+    auto reply = XcbFetch{xcb_query_tree, xcb_query_tree_reply}(connection, window);
+ 
+     if (!reply) {
+       fprintf(stderr, "[Gamescope WSI] getLargestObscuringWindowSize: xcb_query_tree failed for window 0x%x.\n", window);
+@@ -130,8 +210,7 @@ namespace xcb {
+     for (uint32_t i = 0; i < reply->children_len; i++) {
+       xcb_window_t child = children[i];
+ 
+-      xcb_get_window_attributes_cookie_t attributeCookie = xcb_get_window_attributes(connection, child);
+-      auto attributeReply = Reply<xcb_get_window_attributes_reply_t>{ xcb_get_window_attributes_reply(connection, attributeCookie, nullptr) };
+      auto attributeReply = XcbFetch{xcb_get_window_attributes, xcb_get_window_attributes_reply}(connection, child);
+ 
+       const bool obscuring =
+         attributeReply &&
+
+From 1b59621f4de5c05096d1f279cba2e04264124154 Mon Sep 17 00:00:00 2001
+From: sharkautarch <128002472+sharkautarch@users.noreply.github.com>
+Date: Tue, 18 Jun 2024 22:21:23 -0400
+Subject: [PATCH 2/2] WSI: prefetcher: fix issue w/ attempting to prefetch xcb
+ stuff for pure wayland surfaces
+
+---
+ layer/VkLayer_FROG_gamescope_wsi.cpp | 2 +-
+ layer/xcb_helpers.hpp                | 9 ++++++++-
+ 2 files changed, 9 insertions(+), 2 deletions(-)
+
+diff --git a/layer/VkLayer_FROG_gamescope_wsi.cpp b/layer/VkLayer_FROG_gamescope_wsi.cpp
+index f26819a60..ce011dcd7 100644
+--- a/layer/VkLayer_FROG_gamescope_wsi.cpp
+++ b/layer/VkLayer_FROG_gamescope_wsi.cpp
+@@ -1234,7 +1234,7 @@ namespace GamescopeWSILayer {
+             continue;
+           }
+ 
+-          xcb::Prefetcher prefetcher(gamescopeSurface->connection, gamescopeSurface->window);
+          auto prefetcher = xcb::Prefetcher::GetPrefetcherIf(!gamescopeSurface->isWayland(), gamescopeSurface->connection, gamescopeSurface->window);
+           const bool canBypass = gamescopeSurface->canBypassXWayland();
+           if (canBypass != gamescopeSwapchain->isBypassingXWayland)
+             UpdateSwapchainResult(canBypass ? VK_SUBOPTIMAL_KHR : VK_ERROR_OUT_OF_DATE_KHR);
+diff --git a/layer/xcb_helpers.hpp b/layer/xcb_helpers.hpp
+index 72d0ec092..f26aef38b 100644
+--- a/layer/xcb_helpers.hpp
+++ b/layer/xcb_helpers.hpp
+@@ -16,6 +16,13 @@ namespace xcb {
+   
+   //Note: this class is currently only meant to be used within GamescopeWSILayer::VkDeviceOverrides::QueuePresentKHR:
+   struct Prefetcher {
+    static std::optional<Prefetcher> GetPrefetcherIf(bool bCond, xcb_connection_t* connection, const xcb_window_t window) {
+       if (bCond)
+         return std::optional<Prefetcher>(std::in_place_t{}, connection, window);
+       
+       return std::nullopt;
+    }
+    
+     explicit Prefetcher(xcb_connection_t* connection, const xcb_window_t window) {
+         g_cache = {
+             .window = window,
+@@ -90,7 +97,7 @@ namespace xcb {
+         inline Reply<Reply_RetType> operator()(xcb_connection_t* conn, xcb_window_t window) {
+             const bool tryCached = pthread_equal(g_cache_tid, pthread_self())
+                                    && g_cache.window == window;
+-            if (!tryCached) [[unlikely]]
+            if (!tryCached)
+                 return Reply<Reply_RetType> { m_replyFunc(conn, m_cookieFunc(conn, window), nullptr) };
+             
+             auto ret = getCachedReply(conn);
@@ -0,0 +1,5 @@
+project pkg {
+    rpm {
+        spec = "terra-gamescope.spec"
+    }
+}
@@ -0,0 +1,136 @@
+diff --git a/src/Backends/DRMBackend.cpp b/src/Backends/DRMBackend.cpp
+index 85e5126..be418b4 100644
+--- a/src/Backends/DRMBackend.cpp
+++ b/src/Backends/DRMBackend.cpp
+@@ -2149,6 +2149,7 @@ namespace gamescope
+ 			( m_Mutable.szMakePNP == "WLC"sv && m_Mutable.szModel == "ANX7530 U"sv ) ||
+ 			( m_Mutable.szMakePNP == "ANX"sv && m_Mutable.szModel == "ANX7530 U"sv ) ||
+ 			( m_Mutable.szMakePNP == "VLV"sv && m_Mutable.szModel == "ANX7530 U"sv ) ||
+			( m_Mutable.szMakePNP == "DHD"sv && m_Mutable.szModel == "DeckHD-1200p"sv ) ||
+ 			( m_Mutable.szMakePNP == "VLV"sv && m_Mutable.szModel == "Jupiter"sv ) ||
+ 			( m_Mutable.szMakePNP == "VLV"sv && m_Mutable.szModel == "Galileo"sv );
+ 
+@@ -2160,6 +2161,7 @@ namespace gamescope
+ 		{
+ 			static constexpr uint32_t kPIDGalileoSDC = 0x3003;
+ 			static constexpr uint32_t kPIDGalileoBOE = 0x3004;
+			static constexpr uint32_t kPIDJupiterDHD = 0x4001;
+ 
+ 			if ( pProduct->product == kPIDGalileoSDC )
+ 			{
+@@ -2171,6 +2173,10 @@ namespace gamescope
+ 				m_Mutable.eKnownDisplay = GAMESCOPE_KNOWN_DISPLAY_STEAM_DECK_OLED_BOE;
+ 				m_Mutable.ValidDynamicRefreshRates = std::span( s_kSteamDeckOLEDRates );
+ 			}
+			else if (pProduct-> product == kPIDJupiterDHD ) {
+				m_Mutable.eKnownDisplay = GAMESCOPE_KNOWN_DISPLAY_STEAM_DECK_LCD_DHD;
+				m_Mutable.ValidDynamicRefreshRates = std::span( s_kSteamDeckLCDRates );
+			}
+ 			else
+ 			{
+ 				m_Mutable.eKnownDisplay = GAMESCOPE_KNOWN_DISPLAY_STEAM_DECK_LCD;
+@@ -2200,7 +2206,8 @@ namespace gamescope
+ 			drm_log.infof( "[colorimetry]: Steam Deck LCD detected. Using known colorimetry" );
+ 			m_Mutable.DisplayColorimetry = displaycolorimetry_steamdeck_measured;
+ 		}
+-		else
+		else if (m_Mutable.eKnownDisplay == GAMESCOPE_KNOWN_DISPLAY_STEAM_DECK_OLED_BOE ||
+				 m_Mutable.eKnownDisplay == GAMESCOPE_KNOWN_DISPLAY_STEAM_DECK_OLED_SDC )
+ 		{
+ 			// Steam Deck OLED has calibrated chromaticity coordinates in the EDID
+ 			// for each unit.
+@@ -2330,7 +2337,7 @@ namespace gamescope
+ 				.uMinContentLightLevel = nits_to_u16_dark( 0 ),
+ 			};
+ 		}
+-		else if ( eKnownDisplay == GAMESCOPE_KNOWN_DISPLAY_STEAM_DECK_LCD )
+		else if ( eKnownDisplay == GAMESCOPE_KNOWN_DISPLAY_STEAM_DECK_LCD || eKnownDisplay == GAMESCOPE_KNOWN_DISPLAY_STEAM_DECK_LCD_DHD )
+ 		{
+ 			// Set up some HDR fallbacks for undocking
+ 			return BackendConnectorHDRInfo
+diff --git a/src/gamescope_shared.h b/src/gamescope_shared.h
+index ed30d8c..3b60774 100644
+--- a/src/gamescope_shared.h
+++ b/src/gamescope_shared.h
+@@ -8,6 +8,7 @@ namespace gamescope
+ 	{
+ 		GAMESCOPE_KNOWN_DISPLAY_UNKNOWN,
+ 		GAMESCOPE_KNOWN_DISPLAY_STEAM_DECK_LCD,      // Jupiter
+		GAMESCOPE_KNOWN_DISPLAY_STEAM_DECK_LCD_DHD,  // Jupiter Deck HD
+ 		GAMESCOPE_KNOWN_DISPLAY_STEAM_DECK_OLED_SDC, // Galileo SDC
+ 		GAMESCOPE_KNOWN_DISPLAY_STEAM_DECK_OLED_BOE, // Galileo BOE
+ 	};
+diff --git a/src/modegen.cpp b/src/modegen.cpp
+index d174c2d..5dd1136 100644
+--- a/src/modegen.cpp
+++ b/src/modegen.cpp
+@@ -293,13 +293,32 @@ unsigned int galileo_boe_vfp[] =
+ 	172,152,136,120,100,84,68,52,36,20,8
+ };
+ 
+-#define GALILEO_MIN_REFRESH 45
+//SD LCD Stock Timings
+#define JUPITER_BOE_PID     0x3001
+#define JUPITER_B_PID       0x3002
+#define JUPITER_HFP         40
+#define JUPITER_HSYNC       4
+#define JUPITER_HBP         40
+#define JUPITER_VFP         30
+#define JUPITER_VSYNC       4
+#define JUPITER_VBP         8
+//SD LCD DeckHD Timings
+#define JUPITER_DHD_PID     0x4001
+#define JUPITER_DHD_HFP     40
+#define JUPITER_DHD_HSYNC   20
+#define JUPITER_DHD_HBP     40
+#define JUPITER_DHD_VFP     18
+#define JUPITER_DHD_VSYNC   2
+#define JUPITER_DHD_VBP     20
+//SD OLED SDC Timings
+ #define GALILEO_SDC_PID     0x3003
+ #define GALILEO_SDC_VSYNC   1
+ #define GALILEO_SDC_VBP     22
+//SD OLED BOE Timings
+ #define GALILEO_BOE_PID     0x3004
+ #define GALILEO_BOE_VSYNC   2
+ #define GALILEO_BOE_VBP     30
+#define GALILEO_MIN_REFRESH 45
+ #define ARRAY_SIZE(x) (sizeof(x)/sizeof(x[0]))
+ 
+ unsigned int get_galileo_vfp( int vrefresh, unsigned int * vfp_array, unsigned int num_rates )
+@@ -344,17 +363,28 @@ void generate_fixed_mode(drmModeModeInfo *mode, const drmModeModeInfo *base, int
+ 		mode->vsync_end = mode->vsync_start + vsync;
+ 		mode->vtotal = mode->vsync_end + vbp;
+ 	} else {
+-		if ( eKnownDisplay == gamescope::GAMESCOPE_KNOWN_DISPLAY_STEAM_DECK_LCD )
+		if ( eKnownDisplay == gamescope::GAMESCOPE_KNOWN_DISPLAY_STEAM_DECK_LCD_DHD ) {
+			mode->hdisplay = 1200;
+			mode->hsync_start = mode->hdisplay + JUPITER_DHD_HFP;
+			mode->hsync_end = mode->hsync_start + JUPITER_DHD_HSYNC;
+			mode->htotal = mode->hsync_end + JUPITER_DHD_HBP;
+
+			mode->vdisplay = 1920;
+			mode->vsync_start = mode->vdisplay + JUPITER_DHD_VFP;
+			mode->vsync_end = mode->vsync_start + JUPITER_DHD_VSYNC;
+			mode->vtotal = mode->vsync_end + JUPITER_DHD_VBP;
+		}
+		else if ( eKnownDisplay == gamescope::GAMESCOPE_KNOWN_DISPLAY_STEAM_DECK_LCD )
+ 		{
+ 			mode->hdisplay = 800;
+-			mode->hsync_start = 840;
+-			mode->hsync_end = 844;
+-			mode->htotal = 884;
+			mode->hsync_start = mode->hdisplay + JUPITER_HFP;
+			mode->hsync_end = mode->hsync_start + JUPITER_HSYNC;
+			mode->htotal = mode->hsync_end + JUPITER_HBP;
+ 
+ 			mode->vdisplay = 1280;
+-			mode->vsync_start = 1310;
+-			mode->vsync_end = 1314;
+-			mode->vtotal = 1322;
+			mode->vsync_start = mode->vdisplay + JUPITER_VFP;
+			mode->vsync_end = mode->vsync_start + JUPITER_VSYNC;
+			mode->vtotal = mode->vsync_end + JUPITER_VBP;
+ 		}
+ 
+ 		mode->clock = ( ( mode->htotal * mode->vtotal * vrefresh ) + 999 ) / 1000;
@@ -0,0 +1,51 @@
+diff --git a/src/main.cpp b/src/main.cpp
+index 119e043..6c46d97 100644
+--- a/src/main.cpp
+++ b/src/main.cpp
+@@ -148,6 +148,8 @@ const struct option *gamescope_options = (struct option[]){
+ 	{ "reshade-effect", required_argument, nullptr, 0 },
+ 	{ "reshade-technique-idx", required_argument, nullptr, 0 },
+ 
+	{ "disable-touch-click", no_argument, nullptr, 0 },
+
+ 	// Steam Deck options
+ 	{ "mura-map", required_argument, nullptr, 0 },
+ 
+@@ -193,6 +195,7 @@ const char usage[] =
+ 	"  -e, --steam                    enable Steam integration\n"
+ 	"  --bypass-steam-resolution      bypass Steam's default 720p/800p default resolution\n"
+ 	"  --touch-gestures               enable touch gestures for Steam menus\n"
+	"  --disable-touch-click          disable touchscreen tap acting as a click\n"
+ 	"  --xwayland-count               create N xwayland servers\n"
+ 	"  --prefer-vk-device             prefer Vulkan device for compositing (ex: 1002:7300)\n"
+ 	"  --force-orientation            rotate the internal display (left, right, normal, upsidedown)\n"
+diff --git a/src/steamcompmgr.cpp b/src/steamcompmgr.cpp
+index 92bf617..d7498e5 100644
+--- a/src/steamcompmgr.cpp
+++ b/src/steamcompmgr.cpp
+@@ -347,6 +347,7 @@ bool g_bHDRItmEnable = false;
+ int g_nCurrentRefreshRate_CachedValue = 0;
+ gamescope::ConVar<bool> cv_bypass_steam_resolution{ "bypass_steam_resolution", false, "Workaround the 720p/800p limits Steam uses for games" };
+ 
+gamescope::ConVar<bool> cv_disable_touch_click{ "disable_touch_click", false, "Prevents touchscreen taps acting as clicks" };
+ 
+ static void
+ update_color_mgmt()
+@@ -5128,7 +5129,7 @@ handle_property_notify(xwayland_ctx_t *ctx, XPropertyEvent *ev)
+ 			MakeFocusDirty();
+ 		}
+ 	}
+-	if (ev->atom == ctx->atoms.steamTouchClickModeAtom )
+	if (ev->atom == ctx->atoms.steamTouchClickModeAtom && !cv_disable_touch_click)
+ 	{
+ 		gamescope::cv_touch_click_mode = (gamescope::TouchClickMode) get_prop(ctx, ctx->root, ctx->atoms.steamTouchClickModeAtom, 0u );
+ 	}
+@@ -7301,6 +7302,8 @@ steamcompmgr_main(int argc, char **argv)
+ 					g_reshade_technique_idx = atoi(optarg);
+ 				} else if (strcmp(opt_name, "mura-map") == 0) {
+ 					set_mura_overlay(optarg);
+				} else if (strcmp(opt_name, "disable-touch-click") == 0) {
+					cv_disable_touch_click = true;
+ 				}
+ 				break;
+ 			case '?':
@@ -0,0 +1,63 @@
+From 2e4d7ad1bf2cb98eb67ff8f9385cf6657cf2e912 Mon Sep 17 00:00:00 2001
+From: Matthew Schwartz <njtransit215@gmail.com>
+Date: Wed, 3 Jul 2024 15:20:08 -0700
+Subject: [PATCH] drm: Separate BOE and SDC OLED Deck panel valid refresh rates
+
+OLED Decks with BOE panels seem to struggle with a few different
+specific modesets (51hz/55hz/65hz) that SDC panels have no issues with.
+To work around this, let's make use of Gamescope recognizing each
+display manufacturer to correct the bad modesets while leaving
+SDC panel units alone. This can be reverted if an underlying cause can
+be found in the kernel in the future.
+---
+ src/Backends/DRMBackend.cpp | 16 +++++++++++++---
+ 1 file changed, 13 insertions(+), 3 deletions(-)
+
+diff --git a/src/Backends/DRMBackend.cpp b/src/Backends/DRMBackend.cpp
+index 97ef446..9f93c7f 100644
+--- a/src/Backends/DRMBackend.cpp
+++ b/src/Backends/DRMBackend.cpp
+@@ -554,7 +554,7 @@ static constexpr uint32_t s_kSteamDeckLCDRates[] =
+ 	60,
+ };
+ 
+-static constexpr uint32_t s_kSteamDeckOLEDRates[] =
+static constexpr uint32_t s_kSteamDeckOLEDSDCRates[] =
+ {
+ 	45, 47, 48, 49, 
+ 	50, 51, 53, 55, 56, 59, 
+@@ -564,6 +564,16 @@ static constexpr uint32_t s_kSteamDeckOLEDRates[] =
+ 	90, 
+ };
+ 
+static constexpr uint32_t s_kSteamDeckOLEDBOERates[] =
+{
+	45, 47, 48, 49, 
+	50, 53, 56, 59, 
+	60, 62, 64, 66, 68, 
+	72, 73, 76, 77, 78, 
+	80, 81, 82, 84, 85, 86, 87, 88, 
+	90, 
+};
+
+ static void update_connector_display_info_wl(struct drm_t *drm)
+ {
+ 	wlserver_lock();
+@@ -2128,12 +2138,12 @@ namespace gamescope
+ 			if ( pProduct->product == kPIDGalileoSDC )
+ 			{
+ 				m_Mutable.eKnownDisplay = GAMESCOPE_KNOWN_DISPLAY_STEAM_DECK_OLED_SDC;
+-				m_Mutable.ValidDynamicRefreshRates = std::span( s_kSteamDeckOLEDRates );
+				m_Mutable.ValidDynamicRefreshRates = std::span( s_kSteamDeckOLEDSDCRates );
+ 			}
+ 			else if ( pProduct->product == kPIDGalileoBOE )
+ 			{
+ 				m_Mutable.eKnownDisplay = GAMESCOPE_KNOWN_DISPLAY_STEAM_DECK_OLED_BOE;
+-				m_Mutable.ValidDynamicRefreshRates = std::span( s_kSteamDeckOLEDRates );
+				m_Mutable.ValidDynamicRefreshRates = std::span( s_kSteamDeckOLEDBOERates );
+ 			}
+ 			else
+ 			{
+-- 
+2.45.2
+
@@ -0,0 +1,65 @@
+diff --git a/src/steamcompmgr.cpp b/src/steamcompmgr.cpp
+index d7498e5..d1800a8 100644
+--- a/src/steamcompmgr.cpp
+++ b/src/steamcompmgr.cpp
+@@ -3271,7 +3271,7 @@ found:;
+ 		if ( window_has_commits( focus ) ) 
+ 			out->focusWindow = focus;
+ 		else
+-			focus->outdatedInteractiveFocus = true;
+			out->outdatedInteractiveFocus = true;
+ 
+ 		// Always update X's idea of focus, but still dirty
+ 		// the it being outdated so we can resolve that globally later.
+@@ -5995,28 +5995,37 @@ bool handle_done_commit( steamcompmgr_win_t *w, xwayland_ctx_t *ctx, uint64_t co
+ 			// Window just got a new available commit, determine if that's worth a repaint
+ 
+ 			// If this is an overlay that we're presenting, repaint
+-			if ( w == global_focus.overlayWindow && w->opacity != TRANSLUCENT )
+			if ( gameFocused )
+ 			{
+-				hasRepaintNonBasePlane = true;
+-			}
+				if ( w == global_focus.overlayWindow && w->opacity != TRANSLUCENT )
+				{
+					hasRepaintNonBasePlane = true;
+				}
+ 
+-			if ( w == global_focus.notificationWindow && w->opacity != TRANSLUCENT )
+-			{
+-				hasRepaintNonBasePlane = true;
+				if ( w == global_focus.notificationWindow && w->opacity != TRANSLUCENT )
+				{
+					hasRepaintNonBasePlane = true;
+				}
+ 			}
+-
+-			// If this is an external overlay, repaint
+-			if ( w == global_focus.externalOverlayWindow && w->opacity != TRANSLUCENT )
+			if ( ctx )
+ 			{
+-				hasRepaintNonBasePlane = true;
+				if ( ctx->focus.outdatedInteractiveFocus )
+				{
+					MakeFocusDirty();
+					ctx->focus.outdatedInteractiveFocus = false;
+				}
+ 			}
+-
+-			if ( w->outdatedInteractiveFocus )
+			if ( global_focus.outdatedInteractiveFocus )
+ 			{
+ 				MakeFocusDirty();
+-				w->outdatedInteractiveFocus = false;
+-			}
+				global_focus.outdatedInteractiveFocus = false;
+ 
+				// If this is an external overlay, repaint
+				if ( w == global_focus.externalOverlayWindow && w->opacity != TRANSLUCENT )
+				{
+					hasRepaintNonBasePlane = true;
+				}
+			}
+ 			// If this is the main plane, repaint
+ 			if ( w == global_focus.focusWindow && !w->isSteamStreamingClient )
+ 			{
@@ -0,0 +1,7 @@
+prefix=/usr
+includedir=${prefix}/include/stb
+
+Name: stb
+Description: Single-file public domain libraries for C/C++
+Version: 0.1.0
+Cflags: -I${includedir}
@@ -0,0 +1,137 @@
+%global libliftoff_minver 0.4.1
+
+%global _default_patch_fuzz 2
+%global gamescope_tag 3.14.24
+
+Name:           terra-gamescope
+Version:        100.%{gamescope_tag}
+Release:        1%?dist
+Summary:        Micro-compositor for video games on Wayland
+
+License:        BSD
+URL:            https://github.com/ValveSoftware/gamescope
+
+# Create stb.pc to satisfy dependency('stb')
+Source0:        stb.pc
+
+# https://github.com/ChimeraOS/gamescope
+Patch0:         chimeraos.patch
+# https://hhd.dev/
+Patch1:         disable-steam-touch-click-atom.patch
+# https://github.com/ValveSoftware/gamescope/pull/1281
+Patch2:         deckhd.patch
+# https://github.com/ValveSoftware/gamescope/issues/1398
+Patch3:         drm-Separate-BOE-and-SDC-OLED-Deck-panel-rates.patch
+# https://github.com/ValveSoftware/gamescope/issues/1369
+Patch4:         revert-299bc34.patch
+# https://github.com/ValveSoftware/gamescope/pull/1231
+Patch5:         1231.patch
+
+BuildRequires:  meson >= 0.54.0
+BuildRequires:  ninja-build
+BuildRequires:  cmake
+BuildRequires:  gcc
+BuildRequires:  gcc-c++
+BuildRequires:  glm-devel
+BuildRequires:  google-benchmark-devel
+BuildRequires:  libXmu-devel
+BuildRequires:  libXcursor-devel
+BuildRequires:  libeis-devel
+BuildRequires:  pixman-devel
+BuildRequires:  pkgconfig(libdisplay-info)
+BuildRequires:  pkgconfig(pixman-1)
+BuildRequires:  pkgconfig(x11)
+BuildRequires:  pkgconfig(xdamage)
+BuildRequires:  pkgconfig(xcomposite)
+BuildRequires:  pkgconfig(xrender)
+BuildRequires:  pkgconfig(xext)
+BuildRequires:  pkgconfig(xfixes)
+BuildRequires:  pkgconfig(xxf86vm)
+BuildRequires:  pkgconfig(xtst)
+BuildRequires:  pkgconfig(xres)
+BuildRequires:  pkgconfig(libdrm)
+BuildRequires:  pkgconfig(vulkan)
+BuildRequires:  pkgconfig(wayland-scanner)
+BuildRequires:  pkgconfig(wayland-server)
+BuildRequires:  pkgconfig(wayland-protocols) >= 1.17
+BuildRequires:  pkgconfig(xkbcommon)
+BuildRequires:  pkgconfig(sdl2)
+BuildRequires:  pkgconfig(libpipewire-0.3)
+BuildRequires:  pkgconfig(libavif)
+#BuildRequires:  (pkgconfig(wlroots) >= 0.18.0 with pkgconfig(wlroots) < 0.19.0)
+#BuildRequires:  (pkgconfig(libliftoff) >= 0.4.1 with pkgconfig(libliftoff) < 0.5)
+BuildRequires:  pkgconfig(libliftoff)
+BuildRequires:  pkgconfig(libcap)
+BuildRequires:  pkgconfig(hwdata)
+BuildRequires:  pkgconfig(libudev)
+BuildRequires:  pkgconfig(libseat)
+BuildRequires:  pkgconfig(libinput)
+BuildRequires:  xcb-util-wm-devel
+BuildRequires:  pkgconfig(xcb-errors)
+BuildRequires:  spirv-headers-devel
+# Enforce the the minimum EVR to contain fixes for all of:
+# CVE-2021-28021 CVE-2021-42715 CVE-2021-42716 CVE-2022-28041 CVE-2023-43898
+# CVE-2023-45661 CVE-2023-45662 CVE-2023-45663 CVE-2023-45664 CVE-2023-45666
+# CVE-2023-45667
+BuildRequires:  stb_image-devel >= 2.28^20231011gitbeebb24-12
+# Header-only library: -static is for tracking per guidelines
+BuildRequires:  stb_image-static
+BuildRequires:  stb_image_resize-devel
+BuildRequires:  stb_image_resize-static
+BuildRequires:  stb_image_write-devel
+BuildRequires:  stb_image_write-static
+BuildRequires:  /usr/bin/glslangValidator
+BuildRequires:  libdecor-devel
+BuildRequires:  libXdamage-devel
+BuildRequires:  xorg-x11-server-Xwayland-devel
+BuildRequires:  git
+
+# libliftoff hasn't bumped soname, but API/ABI has changed for 0.2.0 release
+Requires:       libliftoff%{?_isa} >= %{libliftoff_minver}
+Requires:       xorg-x11-server-Xwayland
+Requires:       gamescope-libs = %{version}-%{release}
+Requires:       gamescope-libs(x86-32) = %{version}-%{release}
+Recommends:     mesa-dri-drivers
+Recommends:     mesa-vulkan-drivers
+
+%description
+Gamescope is the micro-compositor optimized for running video games on Wayland.
+
+%package libs
+Summary:	libs for Gamescope
+%description libs
+%summary
+
+%prep
+git clone --depth 1 --branch %{gamescope_tag} %{url}.git
+cd gamescope
+git submodule update --init --recursive
+mkdir -p pkgconfig
+cp %{SOURCE0} pkgconfig/stb.pc
+
+# Replace spirv-headers include with the system directory
+sed -i 's^../thirdparty/SPIRV-Headers/include/spirv/^/usr/include/spirv/^' src/meson.build
+
+%autopatch -p1
+
+%build
+cd gamescope
+export PKG_CONFIG_PATH=pkgconfig
+%meson -Dpipewire=enabled -Dinput_emulation=enabled -Ddrm_backend=enabled -Drt_cap=enabled -Davif_screenshots=enabled -Dsdl2_backend=enabled
+%meson_build
+
+%install
+cd gamescope
+%meson_install --skip-subprojects
+
+%files
+%license gamescope/LICENSE
+%doc gamescope/README.md
+%caps(cap_sys_nice=eip) %{_bindir}/gamescope
+%{_bindir}/gamescopectl
+%{_bindir}/gamescopestream
+%{_bindir}/gamescopereaper
+
+%files libs
+%{_libdir}/libVkLayer_FROG_gamescope_wsi_*.so
+%{_datadir}/vulkan/implicit_layer.d/VkLayer_FROG_gamescope_wsi.*.json
@@ -0,0 +1 @@
+rpm.global("gamescope_tag", gh_tag("ValveSoftware/gamescope"));
				`@@ -0,0 +1 @@`
				`rpm.global("gamescope_tag", gh_tag("ValveSoftware/gamescope"));`