implement window sharing

.gitmodules

@@ -1,3 +1,6 @@
 [submodule "wlroots"]
 	path = subprojects/wlroots
 	url = https://gitlab.freedesktop.org/wlroots/wlroots.git
+[submodule "subprojects/hyprland-protocols"]
+	path = subprojects/hyprland-protocols
+	url = https://github.com/hyprwm/hyprland-protocols

CMakeLists.txt

@@ -97,6 +97,7 @@ target_link_libraries(Hyprland
         pthread
         ${CMAKE_THREAD_LIBS_INIT}
         ${CMAKE_SOURCE_DIR}/ext-workspace-unstable-v1-protocol.o
+        ${CMAKE_SOURCE_DIR}/hyprland-toplevel-export-v1-protocol.o
 )
 
 IF(CMAKE_BUILD_TYPE MATCHES Debug OR CMAKE_BUILD_TYPE MATCHES DEBUG)

Makefile

@@ -91,6 +91,16 @@ wlr-output-power-management-unstable-v1-protocol.c:
 
 wlr-output-power-management-unstable-v1-protocol.o: wlr-output-power-management-unstable-v1-protocol.h
 
+hyprland-toplevel-export-v1-protocol.h:
+	$(WAYLAND_SCANNER) server-header \
+		subprojects/hyprland-protocols/protocols/hyprland-toplevel-export-v1.xml $@
+
+hyprland-toplevel-export-v1-protocol.c:
+	$(WAYLAND_SCANNER) private-code \
+		subprojects/hyprland-protocols/protocols/hyprland-toplevel-export-v1.xml $@
+
+hyprland-toplevel-export-v1-protocol.o: hyprland-toplevel-export-v1-protocol.h
+
 linux-dmabuf-unstable-v1-protocol.h:
 	$(WAYLAND_SCANNER) server-header \
 		$(WAYLAND_PROTOCOLS)/unstable/linux-dmabuf/linux-dmabuf-unstable-v1.xml $@
@@ -179,7 +189,7 @@ uninstall:
 	rm -f ${PREFIX}/share/man/man1/Hyprland.1
 	rm -f ${PREFIX}/share/man/man1/hyprctl.1
 
-protocols: xdg-shell-protocol.o wlr-layer-shell-unstable-v1-protocol.o wlr-screencopy-unstable-v1-protocol.o idle-protocol.o ext-workspace-unstable-v1-protocol.o pointer-constraints-unstable-v1-protocol.o tablet-unstable-v2-protocol.o wlr-output-power-management-unstable-v1-protocol.o linux-dmabuf-unstable-v1-protocol.o
+protocols: xdg-shell-protocol.o wlr-layer-shell-unstable-v1-protocol.o wlr-screencopy-unstable-v1-protocol.o idle-protocol.o ext-workspace-unstable-v1-protocol.o pointer-constraints-unstable-v1-protocol.o tablet-unstable-v2-protocol.o wlr-output-power-management-unstable-v1-protocol.o linux-dmabuf-unstable-v1-protocol.o hyprland-toplevel-export-v1-protocol.o
 
 fixwlr:
 	sed -i -E 's/(soversion = 12)([^032]|$$)/soversion = 12032/g' subprojects/wlroots/meson.build

src/Compositor.cpp

@@ -326,6 +326,9 @@ void CCompositor::startCompositor() {
     Debug::log(LOG, "Creating the XWaylandManager!");
     g_pXWaylandManager = std::make_unique<CHyprXWaylandManager>();
 
+    Debug::log(LOG, "Creating the ProtocolManager!");
+    g_pProtocolManager = std::make_unique<CProtocolManager>();
+
     Debug::log(LOG, "Creating the EventManager!");
     g_pEventManager = std::make_unique<CEventManager>();
     g_pEventManager->startThread();
@@ -909,6 +912,15 @@ CWindow* CCompositor::getWindowFromSurface(wlr_surface* pSurface) {
     return nullptr;
 }
 
+CWindow* CCompositor::getWindowFromHandle(uint32_t handle) {
+    for (auto& w : m_vWindows) {
+        if ((uintptr_t)w.get() == (uintptr_t)handle)
+            return w.get();
+    }
+
+    return nullptr;
+}
+
 CWindow* CCompositor::getFullscreenWindowOnWorkspace(const int& ID) {
     for (auto& w : m_vWindows) {
         if (w->m_iWorkspaceID == ID && w->m_bIsFullscreen)

src/Compositor.hpp

@@ -15,6 +15,7 @@
 #include "managers/KeybindManager.hpp"
 #include "managers/AnimationManager.hpp"
 #include "managers/EventManager.hpp"
+#include "managers/ProtocolManager.hpp"
 #include "debug/HyprDebugOverlay.hpp"
 #include "helpers/Monitor.hpp"
 #include "helpers/Workspace.hpp"
@@ -126,6 +127,7 @@ public:
     CMonitor*               getMonitorFromOutput(wlr_output*);
     CWindow*                getWindowForPopup(wlr_xdg_popup*);
     CWindow*                getWindowFromSurface(wlr_surface*);
+    CWindow*                getWindowFromHandle(uint32_t);
     bool                    isWorkspaceVisible(const int&);
     CWorkspace*             getWorkspaceByID(const int&);
     CWorkspace*             getWorkspaceByName(const std::string&);

src/events/Monitors.cpp

@@ -274,6 +274,8 @@ void Events::listener_monitorFrame(void* owner, void* data) {
 
     g_pHyprOpenGL->end();
 
+    g_pProtocolManager->m_pToplevelExportProtocolManager->onMonitorRender(PMONITOR); // dispatch any toplevel sharing
+
     // calc frame damage
     pixman_region32_t frameDamage;
     pixman_region32_init(&frameDamage);

src/managers/ProtocolManager.cpp

@@ -0,0 +1,5 @@
+#include "ProtocolManager.hpp"
+
+CProtocolManager::CProtocolManager() {
+    m_pToplevelExportProtocolManager = std::make_unique<CToplevelExportProtocolManager>();
+}

src/managers/ProtocolManager.hpp

@@ -0,0 +1,13 @@
+#pragma once
+
+#include "../defines.hpp"
+#include "../protocols/ToplevelExport.hpp"
+
+class CProtocolManager {
+public:
+    CProtocolManager();
+
+    std::unique_ptr<CToplevelExportProtocolManager> m_pToplevelExportProtocolManager;
+};
+
+inline std::unique_ptr<CProtocolManager> g_pProtocolManager;

src/protocols/ToplevelExport.cpp

@@ -0,0 +1,359 @@
+#include "ToplevelExport.hpp"
+#include "../Compositor.hpp"
+#include <drm_fourcc.h>
+
+#include <algorithm>
+
+#include "ToplevelExportWlrFuncs.hpp"
+
+#define TOPLEVEL_EXPORT_VERSION 1
+
+static void bindManagerInt(wl_client* client, void* data, uint32_t version, uint32_t id) {
+    g_pProtocolManager->m_pToplevelExportProtocolManager->bindManager(client, data, version, id);
+}
+
+static void handleDisplayDestroy(struct wl_listener* listener, void* data) {
+    g_pProtocolManager->m_pToplevelExportProtocolManager->displayDestroy();
+}
+
+void CToplevelExportProtocolManager::displayDestroy() {
+    wl_global_destroy(m_pGlobal);
+}
+
+CToplevelExportProtocolManager::CToplevelExportProtocolManager() {
+
+#ifndef GLES32
+    Debug::log(WARN, "Toplevel sharing is not supported on LEGACY_RENDERER!");
+    return;
+#endif
+
+    m_pGlobal = wl_global_create(g_pCompositor->m_sWLDisplay, &hyprland_toplevel_export_manager_v1_interface,
+                                 TOPLEVEL_EXPORT_VERSION, this, bindManagerInt);
+
+    if (!m_pGlobal) {
+        Debug::log(ERR, "ToplevelExportManager could not start! Sharing windows will not work!");
+        return;
+    }
+
+    m_liDisplayDestroy.notify = handleDisplayDestroy;
+    wl_display_add_destroy_listener(g_pCompositor->m_sWLDisplay, &m_liDisplayDestroy);
+
+    Debug::log(LOG, "ToplevelExportManager started successfully!");
+}
+
+void handleCaptureToplevel(wl_client* client, wl_resource* resource, uint32_t frame, int32_t overlay_cursor, uint32_t handle) {
+    g_pProtocolManager->m_pToplevelExportProtocolManager->captureToplevel(client, resource, frame, overlay_cursor, handle);
+}
+
+void handleDestroy(wl_client* client, wl_resource* resource) {
+    wl_resource_destroy(resource);
+}
+
+void handleCopyFrame(wl_client* client, wl_resource* resource, wl_resource* buffer, int32_t ignore_damage) {
+    g_pProtocolManager->m_pToplevelExportProtocolManager->copyFrame(client, resource, buffer, ignore_damage);
+}
+
+void handleDestroyFrame(wl_client* client, wl_resource* resource) {
+    wl_resource_destroy(resource);
+}
+
+static const struct hyprland_toplevel_export_manager_v1_interface toplevelExportManagerImpl = {
+    .capture_toplevel = handleCaptureToplevel,
+    .destroy = handleDestroy
+};
+
+static const struct hyprland_toplevel_export_frame_v1_interface toplevelFrameImpl = {
+    .copy = handleCopyFrame,
+    .destroy = handleDestroyFrame
+};
+
+SToplevelClient* clientFromResource(wl_resource* resource) {
+    ASSERT(wl_resource_instance_of(resource, &hyprland_toplevel_export_manager_v1_interface, &toplevelExportManagerImpl));
+    return (SToplevelClient*)wl_resource_get_user_data(resource);
+}
+
+SToplevelFrame* frameFromResource(wl_resource* resource) {
+    ASSERT(wl_resource_instance_of(resource, &hyprland_toplevel_export_frame_v1_interface, &toplevelFrameImpl));
+    return (SToplevelFrame*)wl_resource_get_user_data(resource);
+}
+
+void CToplevelExportProtocolManager::removeClient(SToplevelClient* client) {
+    if (!client || client->ref <= 0)
+        return;
+
+    if (--client->ref != 0)
+        return;
+
+    m_lClients.remove(*client);
+}
+
+void handleManagerResourceDestroy(wl_resource* resource) {
+    const auto PCLIENT = clientFromResource(resource);
+
+    g_pProtocolManager->m_pToplevelExportProtocolManager->removeClient(PCLIENT);
+}
+
+void CToplevelExportProtocolManager::bindManager(wl_client* client, void* data, uint32_t version, uint32_t id) {
+    const auto PCLIENT = &m_lClients.emplace_back();
+
+    PCLIENT->resource = wl_resource_create(client, &hyprland_toplevel_export_manager_v1_interface,
+                                            version, id);
+
+    if (!PCLIENT->resource) {
+        Debug::log(ERR, "ToplevelExportManager could not bind! (out of memory?)");
+        m_lClients.remove(*PCLIENT);
+        wl_client_post_no_memory(client);
+        return;
+    }
+
+    PCLIENT->ref = 1;
+
+    wl_resource_set_implementation(PCLIENT->resource, &toplevelExportManagerImpl, PCLIENT, handleManagerResourceDestroy);
+
+    Debug::log(LOG, "ToplevelExportManager bound successfully!");
+}
+
+void handleFrameResourceDestroy(wl_resource* resource) {
+    const auto PFRAME = frameFromResource(resource);
+
+    g_pProtocolManager->m_pToplevelExportProtocolManager->removeFrame(PFRAME);
+}
+
+void CToplevelExportProtocolManager::removeFrame(SToplevelFrame* frame) {
+    if (!frame)
+        return;
+
+    wl_resource_set_user_data(frame->resource, nullptr);
+    wlr_buffer_unlock(frame->buffer);
+    removeClient(frame->client);
+    m_lFrames.remove(*frame);
+}
+
+void CToplevelExportProtocolManager::captureToplevel(wl_client* client, wl_resource* resource, uint32_t frame, int32_t overlay_cursor, uint32_t handle) {
+    const auto PCLIENT = clientFromResource(resource);
+
+    const auto PWINDOW = g_pCompositor->getWindowFromHandle(handle);
+
+    if (!PWINDOW) {
+        Debug::log(ERR, "Client requested sharing of window handle %x which does not exist!", handle);
+        hyprland_toplevel_export_frame_v1_send_failed(resource);
+        return;
+    }
+
+    if (!PWINDOW->m_bIsMapped || PWINDOW->isHidden()) {
+        Debug::log(ERR, "Client requested sharing of window handle %x which is not shareable!", handle);
+        hyprland_toplevel_export_frame_v1_send_failed(resource);
+        return;
+    }
+
+    // create a frame
+    const auto PFRAME = &m_lFrames.emplace_back();
+    PFRAME->overlayCursor = !!overlay_cursor;
+    PFRAME->resource = wl_resource_create(client, &hyprland_toplevel_export_frame_v1_interface, wl_resource_get_version(resource), frame);
+    PFRAME->pWindow = PWINDOW;
+
+    if (!PFRAME->resource) {
+        Debug::log(ERR, "Couldn't alloc frame for sharing! (no memory)");
+        m_lFrames.remove(*PFRAME);
+        wl_client_post_no_memory(client);
+        return;
+    }
+
+    wl_resource_set_implementation(PFRAME->resource, &toplevelFrameImpl, PFRAME, handleFrameResourceDestroy);
+
+    PFRAME->client = PCLIENT;
+    PCLIENT->ref++;
+
+    const auto PMONITOR = g_pCompositor->getMonitorFromID(PWINDOW->m_iMonitorID);
+
+    PFRAME->shmFormat = wlr_output_preferred_read_format(PMONITOR->output);
+    if (PFRAME->shmFormat == DRM_FORMAT_INVALID) {
+        Debug::log(ERR, "No format supported by renderer in capture toplevel");
+        hyprland_toplevel_export_frame_v1_send_failed(resource);
+        removeFrame(PFRAME);
+        return;
+    }
+
+    const auto PSHMINFO = drm_get_pixel_format_info(PFRAME->shmFormat);
+    if (!PSHMINFO) {
+        Debug::log(ERR, "No pixel format supported by renderer in capture toplevel");
+        hyprland_toplevel_export_frame_v1_send_failed(resource);
+        removeFrame(PFRAME);
+        return;
+    }
+
+    if (PMONITOR->output->allocator && (PMONITOR->output->allocator->buffer_caps & WLR_BUFFER_CAP_DMABUF)) {
+        PFRAME->dmabufFormat = PMONITOR->output->render_format;
+    } else {
+        PFRAME->dmabufFormat = DRM_FORMAT_INVALID;
+    }
+
+    PFRAME->box = {0, 0, (int)PWINDOW->m_vRealSize.vec().x, (int)PWINDOW->m_vRealSize.vec().y};
+    int ow, oh;
+    wlr_output_effective_resolution(PMONITOR->output, &ow, &oh);
+    wlr_box_transform(&PFRAME->box, &PFRAME->box, PMONITOR->transform, ow, oh);
+
+    PFRAME->shmStride = (PSHMINFO->bpp / 8) * PFRAME->box.width;
+
+    hyprland_toplevel_export_frame_v1_send_buffer(PFRAME->resource, convert_drm_format_to_wl_shm(PFRAME->shmFormat), PFRAME->box.width, PFRAME->box.height, PFRAME->shmStride);
+}
+
+void CToplevelExportProtocolManager::copyFrame(wl_client* client, wl_resource* resource, wl_resource* buffer, int32_t ignore_damage) {
+    const auto PFRAME = frameFromResource(resource);
+
+    if (!PFRAME) {
+        Debug::log(ERR, "No frame in copyFrame??");
+        return;
+    }
+
+    if (!PFRAME->pWindow->m_bIsMapped || PFRAME->pWindow->isHidden()) {
+        Debug::log(ERR, "Client requested sharing of window handle %x which is not shareable (2)!", PFRAME->pWindow);
+        hyprland_toplevel_export_frame_v1_send_failed(PFRAME->resource);
+        return;
+    }
+
+    const auto PBUFFER = wlr_buffer_from_resource(buffer);
+    if (!PBUFFER) {
+        wl_resource_post_error(PFRAME->resource, HYPRLAND_TOPLEVEL_EXPORT_FRAME_V1_ERROR_INVALID_BUFFER, "invalid buffer");
+        return;
+    }
+
+    if (PBUFFER->width != PFRAME->box.width || PBUFFER->height != PFRAME->box.height) {
+        wl_resource_post_error(PFRAME->resource, HYPRLAND_TOPLEVEL_EXPORT_FRAME_V1_ERROR_INVALID_BUFFER, "invalid buffer dimensions");
+        return;
+    }
+
+    if (PFRAME->buffer) {
+        wl_resource_post_error(PFRAME->resource, HYPRLAND_TOPLEVEL_EXPORT_FRAME_V1_ERROR_ALREADY_USED, "frame already used");
+        return;
+    }
+
+    wlr_dmabuf_attributes dmabufAttrs;
+    void* wlrBufferAccessData;
+    uint32_t wlrBufferAccessFormat;
+    size_t wlrBufferAccessStride;
+    if (wlr_buffer_get_dmabuf(PBUFFER, &dmabufAttrs)) {
+        PFRAME->bufferCap = WLR_BUFFER_CAP_DMABUF;
+
+        if (dmabufAttrs.format != PFRAME->dmabufFormat) {
+            wl_resource_post_error(PFRAME->resource, HYPRLAND_TOPLEVEL_EXPORT_FRAME_V1_ERROR_INVALID_BUFFER, "invalid buffer format");
+            return;
+        }
+    } else if (wlr_buffer_begin_data_ptr_access(PBUFFER, WLR_BUFFER_DATA_PTR_ACCESS_WRITE, &wlrBufferAccessData, &wlrBufferAccessFormat, &wlrBufferAccessStride)) {
+        wlr_buffer_end_data_ptr_access(PBUFFER);
+
+        if (wlrBufferAccessFormat != PFRAME->shmFormat) {
+            wl_resource_post_error(PFRAME->resource, HYPRLAND_TOPLEVEL_EXPORT_FRAME_V1_ERROR_INVALID_BUFFER, "invalid buffer format");
+            return;
+        } else if ((int)wlrBufferAccessStride != PFRAME->shmStride) {
+            wl_resource_post_error(PFRAME->resource, HYPRLAND_TOPLEVEL_EXPORT_FRAME_V1_ERROR_INVALID_BUFFER, "invalid buffer stride");
+            return;
+        }
+    } else {
+        wl_resource_post_error(PFRAME->resource, HYPRLAND_TOPLEVEL_EXPORT_FRAME_V1_ERROR_INVALID_BUFFER, "invalid buffer type");
+        return;
+    }
+
+    PFRAME->buffer = PBUFFER;
+
+    m_vFramesAwaitingWrite.emplace_back(PFRAME);
+}
+
+void CToplevelExportProtocolManager::onMonitorRender(CMonitor* pMonitor) {
+
+    if (m_vFramesAwaitingWrite.empty())
+        return; // nothing to share
+
+    
+    // share frame if correct output
+    for (auto& f : m_vFramesAwaitingWrite) {
+        if (!g_pHyprRenderer->shouldRenderWindow(f->pWindow, pMonitor))
+            continue;
+
+        shareFrame(f);
+    }
+}
+
+void CToplevelExportProtocolManager::shareFrame(SToplevelFrame* frame) {
+    if (!frame->buffer)
+        return;
+
+    // TODO: damage
+
+    // remove this frame from awaiting.
+    std::erase_if(m_vFramesAwaitingWrite, [&] (const SToplevelFrame* other) { return other == frame; });
+
+    timespec now;
+    clock_gettime(CLOCK_MONOTONIC, &now);
+
+    uint32_t flags = 0;
+    if (frame->bufferCap == WLR_BUFFER_CAP_DMABUF) {
+        if (!copyFrameDmabuf(frame)) {
+            hyprland_toplevel_export_frame_v1_send_failed(frame->resource);
+            removeFrame(frame);
+            return;
+        }
+    } else {
+        if (!copyFrameShm(frame, &now)) {
+            hyprland_toplevel_export_frame_v1_send_failed(frame->resource);
+            removeFrame(frame);
+            return;
+        }
+    }
+
+    hyprland_toplevel_export_frame_v1_send_flags(frame->resource, flags);
+    // todo: send damage
+    uint32_t tvSecHi = (sizeof(now.tv_sec) > 4) ? now.tv_sec >> 32 : 0;
+    uint32_t tvSecLo = now.tv_sec & 0xFFFFFFFF;
+    hyprland_toplevel_export_frame_v1_send_ready(frame->resource, tvSecHi, tvSecLo, now.tv_nsec);
+    removeFrame(frame);
+}
+
+bool CToplevelExportProtocolManager::copyFrameShm(SToplevelFrame* frame, timespec* now) {
+    void* data;
+    uint32_t format;
+    size_t stride;
+    if (!wlr_buffer_begin_data_ptr_access(frame->buffer, WLR_BUFFER_DATA_PTR_ACCESS_WRITE, &data, &format, &stride))
+        return false;
+
+    // render the client
+    const auto PMONITOR = g_pCompositor->getMonitorFromID(frame->pWindow->m_iMonitorID);
+    pixman_region32_t fakeDamage;
+    pixman_region32_init_rect(&fakeDamage, 0, 0, PMONITOR->vecPixelSize.x * 10, PMONITOR->vecPixelSize.y * 10);
+
+    g_pHyprOpenGL->begin(PMONITOR, &fakeDamage, true);
+    g_pHyprOpenGL->clear(CColor(0, 0, 0, 255));
+
+    // render client at 0,0
+    g_pHyprRenderer->renderWindow(frame->pWindow, PMONITOR, now, false, RENDER_PASS_ALL, true, true);
+
+    // copy pixels
+    const auto PFORMAT = get_gles2_format_from_drm(format);
+    if (!PFORMAT) {
+        Debug::log(ERR, "Cannot read pixels, unsupported format %x", PFORMAT);
+        g_pHyprOpenGL->end();
+        pixman_region32_fini(&fakeDamage);
+        wlr_buffer_end_data_ptr_access(frame->buffer);
+        return false;
+    }
+
+    glBindFramebuffer(GL_FRAMEBUFFER, g_pHyprOpenGL->m_RenderData.pCurrentMonData->primaryFB.m_iFb);
+
+    glFinish(); // flush
+
+    glReadPixels(0, 0, frame->box.width, frame->box.height, PFORMAT->gl_format, PFORMAT->gl_type, data);
+
+    g_pHyprOpenGL->end();
+
+    pixman_region32_fini(&fakeDamage);
+
+    wlr_buffer_end_data_ptr_access(frame->buffer);
+
+    return true;
+}
+
+bool CToplevelExportProtocolManager::copyFrameDmabuf(SToplevelFrame* frame) {
+    // todo
+    Debug::log(ERR, "DMABUF copying not impl'd!");
+    return false;
+}

src/protocols/ToplevelExport.hpp

@@ -0,0 +1,68 @@
+#pragma once
+
+#include "../defines.hpp"
+#include "hyprland-toplevel-export-v1-protocol.h"
+
+#include <list>
+#include <vector>
+
+class CMonitor;
+class CWindow;
+
+struct SToplevelClient {
+    int ref = 0;
+    wl_resource* resource = nullptr;
+
+    bool operator==(const SToplevelClient& other) {
+        return resource == other.resource;
+    }
+};
+
+struct SToplevelFrame {
+    wl_resource* resource = nullptr;
+    SToplevelClient* client = nullptr;
+
+    uint32_t    shmFormat = 0;
+    uint32_t    dmabufFormat = 0;
+    wlr_box     box = { 0 };
+    int         shmStride = 0;
+
+    bool        overlayCursor = false;
+
+    wlr_buffer_cap bufferCap = WLR_BUFFER_CAP_SHM;
+
+    wlr_buffer* buffer = nullptr;
+
+    CWindow*    pWindow = nullptr;
+
+    bool operator==(const SToplevelFrame& other) { 
+        return resource == other.resource && client == other.client;
+    }
+};
+
+class CToplevelExportProtocolManager {
+public:
+    CToplevelExportProtocolManager();
+
+    void        bindManager(wl_client* client, void* data, uint32_t version, uint32_t id);
+    void        captureToplevel(wl_client* client, wl_resource* resource, uint32_t frame, int32_t overlay_cursor, uint32_t handle);
+    void        removeClient(SToplevelClient* client);
+    void        removeFrame(SToplevelFrame* frame);
+    void        copyFrame(wl_client* client, wl_resource* resource, wl_resource* buffer, int32_t ignore_damage);
+
+    void        onMonitorRender(CMonitor* pMonitor);
+    void        displayDestroy();
+
+private:
+    wl_global*                  m_pGlobal = nullptr;
+    std::list<SToplevelFrame>   m_lFrames;
+    std::list<SToplevelClient>  m_lClients;
+
+    wl_listener                 m_liDisplayDestroy;
+
+    std::vector<SToplevelFrame*> m_vFramesAwaitingWrite;
+
+    void        shareFrame(SToplevelFrame* frame);
+    bool        copyFrameDmabuf(SToplevelFrame* frame);
+    bool        copyFrameShm(SToplevelFrame* frame, timespec* now);
+};

src/protocols/ToplevelExportWlrFuncs.hpp

@@ -0,0 +1,312 @@
+#include <GLES2/gl2ext.h>
+
+struct wlr_pixel_format_info {
+    uint32_t drm_format;
+
+    /* Equivalent of the format if it has an alpha channel,
+	 * DRM_FORMAT_INVALID (0) if NA
+	 */
+    uint32_t opaque_substitute;
+
+    /* Bits per pixels */
+    uint32_t bpp;
+
+    /* True if the format has an alpha channel */
+    bool has_alpha;
+};
+
+static const struct wlr_pixel_format_info pixel_format_info[] = {
+    {
+        .drm_format = DRM_FORMAT_XRGB8888,
+        .opaque_substitute = DRM_FORMAT_INVALID,
+        .bpp = 32,
+        .has_alpha = false,
+    },
+    {
+        .drm_format = DRM_FORMAT_ARGB8888,
+        .opaque_substitute = DRM_FORMAT_XRGB8888,
+        .bpp = 32,
+        .has_alpha = true,
+    },
+    {
+        .drm_format = DRM_FORMAT_XBGR8888,
+        .opaque_substitute = DRM_FORMAT_INVALID,
+        .bpp = 32,
+        .has_alpha = false,
+    },
+    {
+        .drm_format = DRM_FORMAT_ABGR8888,
+        .opaque_substitute = DRM_FORMAT_XBGR8888,
+        .bpp = 32,
+        .has_alpha = true,
+    },
+    {
+        .drm_format = DRM_FORMAT_RGBX8888,
+        .opaque_substitute = DRM_FORMAT_INVALID,
+        .bpp = 32,
+        .has_alpha = false,
+    },
+    {
+        .drm_format = DRM_FORMAT_RGBA8888,
+        .opaque_substitute = DRM_FORMAT_RGBX8888,
+        .bpp = 32,
+        .has_alpha = true,
+    },
+    {
+        .drm_format = DRM_FORMAT_BGRX8888,
+        .opaque_substitute = DRM_FORMAT_INVALID,
+        .bpp = 32,
+        .has_alpha = false,
+    },
+    {
+        .drm_format = DRM_FORMAT_BGRA8888,
+        .opaque_substitute = DRM_FORMAT_BGRX8888,
+        .bpp = 32,
+        .has_alpha = true,
+    },
+    {
+        .drm_format = DRM_FORMAT_BGR888,
+        .opaque_substitute = DRM_FORMAT_INVALID,
+        .bpp = 24,
+        .has_alpha = false,
+    },
+    {
+        .drm_format = DRM_FORMAT_RGBX4444,
+        .opaque_substitute = DRM_FORMAT_INVALID,
+        .bpp = 16,
+        .has_alpha = false,
+    },
+    {
+        .drm_format = DRM_FORMAT_RGBA4444,
+        .opaque_substitute = DRM_FORMAT_RGBX4444,
+        .bpp = 16,
+        .has_alpha = true,
+    },
+    {
+        .drm_format = DRM_FORMAT_RGBX5551,
+        .opaque_substitute = DRM_FORMAT_INVALID,
+        .bpp = 16,
+        .has_alpha = false,
+    },
+    {
+        .drm_format = DRM_FORMAT_RGBA5551,
+        .opaque_substitute = DRM_FORMAT_RGBX5551,
+        .bpp = 16,
+        .has_alpha = true,
+    },
+    {
+        .drm_format = DRM_FORMAT_RGB565,
+        .opaque_substitute = DRM_FORMAT_INVALID,
+        .bpp = 16,
+        .has_alpha = false,
+    },
+    {
+        .drm_format = DRM_FORMAT_BGR565,
+        .opaque_substitute = DRM_FORMAT_INVALID,
+        .bpp = 16,
+        .has_alpha = false,
+    },
+    {
+        .drm_format = DRM_FORMAT_XRGB2101010,
+        .opaque_substitute = DRM_FORMAT_INVALID,
+        .bpp = 32,
+        .has_alpha = false,
+    },
+    {
+        .drm_format = DRM_FORMAT_ARGB2101010,
+        .opaque_substitute = DRM_FORMAT_XRGB2101010,
+        .bpp = 32,
+        .has_alpha = true,
+    },
+    {
+        .drm_format = DRM_FORMAT_XBGR2101010,
+        .opaque_substitute = DRM_FORMAT_INVALID,
+        .bpp = 32,
+        .has_alpha = false,
+    },
+    {
+        .drm_format = DRM_FORMAT_ABGR2101010,
+        .opaque_substitute = DRM_FORMAT_XBGR2101010,
+        .bpp = 32,
+        .has_alpha = true,
+    },
+    {
+        .drm_format = DRM_FORMAT_XBGR16161616F,
+        .opaque_substitute = DRM_FORMAT_INVALID,
+        .bpp = 64,
+        .has_alpha = false,
+    },
+    {
+        .drm_format = DRM_FORMAT_ABGR16161616F,
+        .opaque_substitute = DRM_FORMAT_XBGR16161616F,
+        .bpp = 64,
+        .has_alpha = true,
+    },
+    {
+        .drm_format = DRM_FORMAT_XBGR16161616,
+        .opaque_substitute = DRM_FORMAT_INVALID,
+        .bpp = 64,
+        .has_alpha = false,
+    },
+    {
+        .drm_format = DRM_FORMAT_ABGR16161616,
+        .opaque_substitute = DRM_FORMAT_XBGR16161616,
+        .bpp = 64,
+        .has_alpha = true,
+    },
+};
+
+static const size_t pixel_format_info_size =
+    sizeof(pixel_format_info) / sizeof(pixel_format_info[0]);
+
+const struct wlr_pixel_format_info* drm_get_pixel_format_info(uint32_t fmt) {
+    for (size_t i = 0; i < pixel_format_info_size; ++i) {
+        if (pixel_format_info[i].drm_format == fmt) {
+            return &pixel_format_info[i];
+        }
+    }
+
+    return NULL;
+}
+
+uint32_t convert_wl_shm_format_to_drm(enum wl_shm_format fmt) {
+    switch (fmt) {
+        case WL_SHM_FORMAT_XRGB8888:
+            return DRM_FORMAT_XRGB8888;
+        case WL_SHM_FORMAT_ARGB8888:
+            return DRM_FORMAT_ARGB8888;
+        default:
+            return (uint32_t)fmt;
+    }
+}
+
+enum wl_shm_format convert_drm_format_to_wl_shm(uint32_t fmt) {
+    switch (fmt) {
+        case DRM_FORMAT_XRGB8888:
+            return WL_SHM_FORMAT_XRGB8888;
+        case DRM_FORMAT_ARGB8888:
+            return WL_SHM_FORMAT_ARGB8888;
+        default:
+            return (enum wl_shm_format)fmt;
+    }
+}
+
+struct wlr_gles2_pixel_format {
+    uint32_t drm_format;
+    // optional field, if empty then internalformat = format
+    GLint gl_internalformat;
+    GLint gl_format, gl_type;
+    bool has_alpha;
+};
+
+static const struct wlr_gles2_pixel_format formats[] = {
+    {
+        .drm_format = DRM_FORMAT_ARGB8888,
+        .gl_format = GL_BGRA_EXT,
+        .gl_type = GL_UNSIGNED_BYTE,
+        .has_alpha = true,
+    },
+    {
+        .drm_format = DRM_FORMAT_XRGB8888,
+        .gl_format = GL_BGRA_EXT,
+        .gl_type = GL_UNSIGNED_BYTE,
+        .has_alpha = false,
+    },
+    {
+        .drm_format = DRM_FORMAT_XBGR8888,
+        .gl_format = GL_RGBA,
+        .gl_type = GL_UNSIGNED_BYTE,
+        .has_alpha = false,
+    },
+    {
+        .drm_format = DRM_FORMAT_ABGR8888,
+        .gl_format = GL_RGBA,
+        .gl_type = GL_UNSIGNED_BYTE,
+        .has_alpha = true,
+    },
+    {
+        .drm_format = DRM_FORMAT_BGR888,
+        .gl_format = GL_RGB,
+        .gl_type = GL_UNSIGNED_BYTE,
+        .has_alpha = false,
+    },
+#if WLR_LITTLE_ENDIAN
+    {
+        .drm_format = DRM_FORMAT_RGBX4444,
+        .gl_format = GL_RGBA,
+        .gl_type = GL_UNSIGNED_SHORT_4_4_4_4,
+        .has_alpha = false,
+    },
+    {
+        .drm_format = DRM_FORMAT_RGBA4444,
+        .gl_format = GL_RGBA,
+        .gl_type = GL_UNSIGNED_SHORT_4_4_4_4,
+        .has_alpha = true,
+    },
+    {
+        .drm_format = DRM_FORMAT_RGBX5551,
+        .gl_format = GL_RGBA,
+        .gl_type = GL_UNSIGNED_SHORT_5_5_5_1,
+        .has_alpha = false,
+    },
+    {
+        .drm_format = DRM_FORMAT_RGBA5551,
+        .gl_format = GL_RGBA,
+        .gl_type = GL_UNSIGNED_SHORT_5_5_5_1,
+        .has_alpha = true,
+    },
+    {
+        .drm_format = DRM_FORMAT_RGB565,
+        .gl_format = GL_RGB,
+        .gl_type = GL_UNSIGNED_SHORT_5_6_5,
+        .has_alpha = false,
+    },
+    {
+        .drm_format = DRM_FORMAT_XBGR2101010,
+        .gl_format = GL_RGBA,
+        .gl_type = GL_UNSIGNED_INT_2_10_10_10_REV_EXT,
+        .has_alpha = false,
+    },
+    {
+        .drm_format = DRM_FORMAT_ABGR2101010,
+        .gl_format = GL_RGBA,
+        .gl_type = GL_UNSIGNED_INT_2_10_10_10_REV_EXT,
+        .has_alpha = true,
+    },
+    {
+        .drm_format = DRM_FORMAT_XBGR16161616F,
+        .gl_format = GL_RGBA,
+        .gl_type = GL_HALF_FLOAT_OES,
+        .has_alpha = false,
+    },
+    {
+        .drm_format = DRM_FORMAT_ABGR16161616F,
+        .gl_format = GL_RGBA,
+        .gl_type = GL_HALF_FLOAT_OES,
+        .has_alpha = true,
+    },
+    {
+        .drm_format = DRM_FORMAT_XBGR16161616,
+        .gl_internalformat = GL_RGBA16_EXT,
+        .gl_format = GL_RGBA,
+        .gl_type = GL_UNSIGNED_SHORT,
+        .has_alpha = false,
+    },
+    {
+        .drm_format = DRM_FORMAT_ABGR16161616,
+        .gl_internalformat = GL_RGBA16_EXT,
+        .gl_format = GL_RGBA,
+        .gl_type = GL_UNSIGNED_SHORT,
+        .has_alpha = true,
+    },
+#endif
+};
+
+const struct wlr_gles2_pixel_format* get_gles2_format_from_drm(uint32_t fmt) {
+    for (size_t i = 0; i < sizeof(formats) / sizeof(*formats); ++i) {
+        if (formats[i].drm_format == fmt) {
+            return &formats[i];
+        }
+    }
+    return NULL;
+}

src/render/Renderer.cpp

@@ -215,7 +215,7 @@ void CHyprRenderer::renderWorkspaceWithFullscreenWindow(CMonitor* pMonitor, CWor
         g_pHyprError->draw();
 }
 
-void CHyprRenderer::renderWindow(CWindow* pWindow, CMonitor* pMonitor, timespec* time, bool decorate, eRenderPassMode mode, bool ignorePosition) {
+void CHyprRenderer::renderWindow(CWindow* pWindow, CMonitor* pMonitor, timespec* time, bool decorate, eRenderPassMode mode, bool ignorePosition, bool ignoreAllGeometry) {
     if (pWindow->isHidden())
         return;
 
@@ -235,6 +235,9 @@ void CHyprRenderer::renderWindow(CWindow* pWindow, CMonitor* pMonitor, timespec*
         renderdata.y = pMonitor->vecPosition.y;
     }
 
+    if (ignoreAllGeometry)
+        decorate = false;
+
     renderdata.surface = g_pXWaylandManager->getWindowSurface(pWindow);
     renderdata.w = std::max(pWindow->m_vRealSize.vec().x, 5.0); // clamp the size to min 5,
     renderdata.h = std::max(pWindow->m_vRealSize.vec().y, 5.0); // otherwise we'll have issues later with invalid boxes
@@ -242,8 +245,8 @@ void CHyprRenderer::renderWindow(CWindow* pWindow, CMonitor* pMonitor, timespec*
     renderdata.fadeAlpha = pWindow->m_fAlpha.fl() * (pWindow->m_bPinned ? 1.f : (PWORKSPACE->m_fAlpha.fl() / 255.f));
     renderdata.alpha = pWindow->m_fActiveInactiveAlpha.fl();
     renderdata.decorate = decorate && !pWindow->m_bX11DoesntWantBorders && (pWindow->m_bIsFloating ? *PNOFLOATINGBORDERS == 0 : true) && (!pWindow->m_bIsFullscreen || PWORKSPACE->m_efFullscreenMode != FULLSCREEN_FULL);
-    renderdata.rounding = pWindow->m_sAdditionalConfigData.rounding;
-    renderdata.blur = true; // if it shouldn't, it will be ignored later
+    renderdata.rounding = ignoreAllGeometry ? 0 : pWindow->m_sAdditionalConfigData.rounding;
+    renderdata.blur = !ignoreAllGeometry; // if it shouldn't, it will be ignored later
     renderdata.pWindow = pWindow;
 
     // apply window special data

src/render/Renderer.hpp

@@ -23,6 +23,8 @@ enum eRenderPassMode {
     RENDER_PASS_POPUP
 };
 
+class CToplevelExportProtocolManager;
+
 class CHyprRenderer {
 public:
 
@@ -54,7 +56,7 @@ public:
 private:
     void                arrangeLayerArray(CMonitor*, const std::vector<std::unique_ptr<SLayerSurface>>&, bool, wlr_box*);
     void                renderWorkspaceWithFullscreenWindow(CMonitor*, CWorkspace*, timespec*);
-    void                renderWindow(CWindow*, CMonitor*, timespec*, bool, eRenderPassMode, bool ignorePosition = false);
+    void                renderWindow(CWindow*, CMonitor*, timespec*, bool, eRenderPassMode, bool ignorePosition = false, bool ignoreAllGeometry = false);
     void                renderLayer(SLayerSurface*, CMonitor*, timespec*);
     void                renderDragIcon(CMonitor*, timespec*);
     void                renderIMEPopup(SIMEPopup*, CMonitor*, timespec*);
@@ -63,6 +65,7 @@ private:
 
 
     friend class CHyprOpenGLImpl;
+    friend class CToplevelExportProtocolManager;
 };
 
 inline std::unique_ptr<CHyprRenderer> g_pHyprRenderer;

subprojects/hyprland-protocols

@@ -0,0 +1 @@
+Subproject commit 64dc1edc475bd80c486b8c93d3875a74a94389da