drop wlroots

CMakeLists.txt

@@ -31,9 +31,6 @@ execute_process(
 # udis
 add_subdirectory("subprojects/udis86")
 
-# wlroots
-message(STATUS "Setting up wlroots")
-
 if(CMAKE_BUILD_TYPE)
     string(TOLOWER ${CMAKE_BUILD_TYPE} BUILDTYPE_LOWER)
     if(BUILDTYPE_LOWER STREQUAL "release")
@@ -53,18 +50,6 @@ else()
     set(BUILDTYPE_LOWER "release")
 endif()
 
-ExternalProject_Add(
-    wlroots-hyprland
-    PREFIX ${CMAKE_SOURCE_DIR}/subprojects/wlroots-hyprland
-    SOURCE_DIR ${CMAKE_SOURCE_DIR}/subprojects/wlroots-hyprland
-    CONFIGURE_COMMAND meson setup --reconfigure --clearcache build --buildtype=${BUILDTYPE_LOWER} -Dwerror=false -Dxwayland=$<IF:$<BOOL:${NO_XWAYLAND}>,disabled,enabled> -Dexamples=false -Drenderers=gles2 -Dbackends=drm,libinput $<IF:$<BOOL:${WITH_ASAN}>,-Db_sanitize=address,-Db_sanitize=none>
-    BUILD_COMMAND ninja -C build
-    BUILD_ALWAYS true
-    BUILD_IN_SOURCE true
-    BUILD_BYPRODUCTS ${CMAKE_SOURCE_DIR}/subprojects/wlroots-hyprland/build/libwlroots.a
-    INSTALL_COMMAND echo "wlroots-hyprland: install not needed"
-)
-
 find_package(PkgConfig REQUIRED)
 
 pkg_get_variable(WaylandScanner wayland-scanner wayland_scanner)
@@ -84,8 +69,6 @@ endif()
 include_directories(
   .
   "src/"
-  "subprojects/wlroots-hyprland/include/"
-  "subprojects/wlroots-hyprland/build/include/"
   "subprojects/udis86/"
   "protocols/")
 set(CMAKE_CXX_STANDARD 23)
@@ -112,7 +95,7 @@ pkg_check_modules(deps REQUIRED IMPORTED_TARGET
     aquamarine
     xkbcommon uuid
     wayland-server wayland-client wayland-cursor wayland-protocols
-    cairo pango pangocairo pixman-1
+    cairo pango pangocairo pixman-1 xcursor
     libdrm libinput hwdata libseat libdisplay-info libliftoff libudev gbm
     hyprlang>=0.3.2 hyprcursor>=0.1.7 hyprutils>=0.1.5
 )
@@ -128,7 +111,6 @@ if(USE_TRACY)
 endif()
 
 add_executable(Hyprland ${SRCFILES} ${TRACY_CPP_FILES})
-add_dependencies(Hyprland wlroots-hyprland)
 
 set(USE_GPROF ON)
 
@@ -267,7 +249,6 @@ function(protocolWayland)
 endfunction()
 
 target_link_libraries(Hyprland
-        ${CMAKE_SOURCE_DIR}/subprojects/wlroots-hyprland/build/libwlroots.a
         OpenGL::EGL
         OpenGL::GL
         Threads::Threads
@@ -360,18 +341,6 @@ install(FILES ${MANPAGES}
 install(FILES ${CMAKE_BINARY_DIR}/hyprland.pc
         DESTINATION ${CMAKE_INSTALL_DATAROOTDIR}/pkgconfig)
 
-# wlroots headers
-set(HEADERS_WLR "${CMAKE_CURRENT_SOURCE_DIR}/subprojects/wlroots-hyprland/include/wlr")
-install(DIRECTORY ${HEADERS_WLR}
-        DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/hyprland
-        FILES_MATCHING PATTERN "*.h")
-
-# config.h and version.h
-set(HEADERS_WLR_ROOT "${CMAKE_CURRENT_SOURCE_DIR}/subprojects/wlroots-hyprland/build/include/wlr")
-install(DIRECTORY ${HEADERS_WLR_ROOT}/
-        DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/hyprland/wlr
-        FILES_MATCHING PATTERN "*.h")
-
 # protocol headers
 set(HEADERS_PROTO "${CMAKE_CURRENT_SOURCE_DIR}/protocols")
 install(DIRECTORY ${HEADERS_PROTO}

src/Compositor.cpp

@@ -7,6 +7,7 @@
 #include "managers/SeatManager.hpp"
 #include "managers/eventLoop/EventLoopManager.hpp"
 #include <random>
+#include <cstring>
 #include <unordered_set>
 #include "debug/HyprCtl.hpp"
 #include "debug/CrashReporter.hpp"

src/debug/Log.cpp

@@ -10,30 +10,6 @@ void Debug::init(const std::string& IS) {
     logFile = IS + (ISDEBUG ? "/hyprlandd.log" : "/hyprland.log");
 }
 
-void Debug::wlrLog(wlr_log_importance level, const char* fmt, va_list args) {
-    if (level > wlr_log_get_verbosity())
-        return;
-
-    char* outputStr = nullptr;
-
-    vasprintf(&outputStr, fmt, args);
-
-    std::string output = std::string(outputStr);
-    free(outputStr);
-
-    rollingLog += output + "\n";
-
-    if (!disableLogs || !**disableLogs) {
-        std::ofstream ofs;
-        ofs.open(logFile, std::ios::out | std::ios::app);
-        ofs << "[wlr] " << output << "\n";
-        ofs.close();
-    }
-
-    if (!disableStdout)
-        std::cout << output << "\n";
-}
-
 void Debug::log(LogLevel level, std::string str) {
     if (level == TRACE && !trace)
         return;

src/debug/Log.hpp

@@ -67,6 +67,4 @@ namespace Debug {
 
         log(level, logMsg);
     }
-
-    void wlrLog(wlr_log_importance level, const char* fmt, va_list args);
 };

src/devices/IKeyboard.cpp

@@ -5,6 +5,9 @@
 #include "../managers/SeatManager.hpp"
 #include <sys/mman.h>
 #include <aquamarine/input/Input.hpp>
+#include <cstring>
+
+#define LED_COUNT 3
 
 constexpr static std::array<const char*, 8> MODNAMES = {
     XKB_MOD_NAME_SHIFT, XKB_MOD_NAME_CAPS, XKB_MOD_NAME_CTRL, XKB_MOD_NAME_ALT, XKB_MOD_NAME_NUM, "Mod3", XKB_MOD_NAME_LOGO, "Mod5",
@@ -256,7 +259,7 @@ void IKeyboard::updateLEDs() {
         return;
 
     uint32_t leds = 0;
-    for (uint32_t i = 0; i < WLR_LED_COUNT; ++i) {
+    for (uint32_t i = 0; i < LED_COUNT; ++i) {
         if (xkb_state_led_index_is_active(xkbState, ledIndexes.at(i)))
             leds |= (1 << i);
     }

src/devices/IKeyboard.hpp

@@ -9,6 +9,17 @@
 
 AQUAMARINE_FORWARD(IKeyboard);
 
+enum eKeyboardModifiers {
+    HL_MODIFIER_SHIFT = (1 << 0),
+    HL_MODIFIER_CAPS  = (1 << 1),
+    HL_MODIFIER_CTRL  = (1 << 2),
+    HL_MODIFIER_ALT   = (1 << 3),
+    HL_MODIFIER_MOD2  = (1 << 4),
+    HL_MODIFIER_MOD3  = (1 << 5),
+    HL_MODIFIER_META  = (1 << 6),
+    HL_MODIFIER_MOD5  = (1 << 7),
+};
+
 class IKeyboard : public IHID {
   public:
     virtual ~IKeyboard();

src/helpers/MiscFunctions.cpp

@@ -4,9 +4,12 @@
 #include "../Compositor.hpp"
 #include "../managers/TokenManager.hpp"
 #include <optional>
+#include <cstring>
+#include <cmath>
 #include <set>
 #include <sys/utsname.h>
 #include <sys/mman.h>
+#include <sys/stat.h>
 #include <fcntl.h>
 #include <iomanip>
 #include <sstream>

src/helpers/Monitor.cpp

@@ -1,5 +1,6 @@
 #include "Monitor.hpp"
 #include "MiscFunctions.hpp"
+#include "math/Math.hpp"
 #include "../Compositor.hpp"
 #include "../config/ConfigValue.hpp"
 #include "../protocols/GammaControl.hpp"
@@ -727,11 +728,11 @@ Vector2D CMonitor::middle() {
 }
 
 void CMonitor::updateMatrix() {
-    wlr_matrix_identity(projMatrix.data());
+    matrixIdentity(projMatrix.data());
     if (transform != WL_OUTPUT_TRANSFORM_NORMAL) {
-        wlr_matrix_translate(projMatrix.data(), vecPixelSize.x / 2.0, vecPixelSize.y / 2.0);
+        matrixTranslate(projMatrix.data(), vecPixelSize.x / 2.0, vecPixelSize.y / 2.0);
-        wlr_matrix_transform(projMatrix.data(), transform);
+        matrixTransform(projMatrix.data(), wlTransformToHyprutils(transform));
-        wlr_matrix_translate(projMatrix.data(), -vecTransformedSize.x / 2.0, -vecTransformedSize.y / 2.0);
+        matrixTranslate(projMatrix.data(), -vecTransformedSize.x / 2.0, -vecTransformedSize.y / 2.0);
     }
 }
 

src/helpers/math/Math.cpp

@@ -17,14 +17,14 @@ Hyprutils::Math::eTransform wlTransformToHyprutils(wl_output_transform t) {
     return Hyprutils::Math::eTransform::HYPRUTILS_TRANSFORM_NORMAL;
 }
 
-static void matrixIdentity(float mat[9]) {
+void matrixIdentity(float mat[9]) {
     static const float identity[9] = {
         1.0f, 0.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f, 0.0f, 1.0f,
     };
     memcpy(mat, identity, sizeof(identity));
 }
 
-static void matrixMultiply(float mat[9], const float a[9], const float b[9]) {
+void matrixMultiply(float mat[9], const float a[9], const float b[9]) {
     float product[9];
 
     product[0] = a[0] * b[0] + a[1] * b[3] + a[2] * b[6];
@@ -42,35 +42,35 @@ static void matrixMultiply(float mat[9], const float a[9], const float b[9]) {
     memcpy(mat, product, sizeof(product));
 }
 
-static void matrixTranspose(float mat[9], const float a[9]) {
+void matrixTranspose(float mat[9], const float a[9]) {
     float transposition[9] = {
         a[0], a[3], a[6], a[1], a[4], a[7], a[2], a[5], a[8],
     };
     memcpy(mat, transposition, sizeof(transposition));
 }
 
-static void matrixTranslate(float mat[9], float x, float y) {
+void matrixTranslate(float mat[9], float x, float y) {
     float translate[9] = {
         1.0f, 0.0f, x, 0.0f, 1.0f, y, 0.0f, 0.0f, 1.0f,
     };
     matrixMultiply(mat, mat, translate);
 }
 
-static void matrixScale(float mat[9], float x, float y) {
+void matrixScale(float mat[9], float x, float y) {
     float scale[9] = {
         x, 0.0f, 0.0f, 0.0f, y, 0.0f, 0.0f, 0.0f, 1.0f,
     };
     matrixMultiply(mat, mat, scale);
 }
 
-static void matrixRotate(float mat[9], float rad) {
+void matrixRotate(float mat[9], float rad) {
     float rotate[9] = {
         cos(rad), -sin(rad), 0.0f, sin(rad), cos(rad), 0.0f, 0.0f, 0.0f, 1.0f,
     };
     matrixMultiply(mat, mat, rotate);
 }
 
-static std::unordered_map<eTransform, std::array<float, 9>> transforms = {
+std::unordered_map<eTransform, std::array<float, 9>> transforms = {
     {HYPRUTILS_TRANSFORM_NORMAL,
      {
          1.0f,
@@ -169,11 +169,11 @@ static std::unordered_map<eTransform, std::array<float, 9>> transforms = {
      }},
 };
 
-static void matrixTransform(float mat[9], eTransform transform) {
+void matrixTransform(float mat[9], eTransform transform) {
     matrixMultiply(mat, mat, transforms.at(transform).data());
 }
 
-static void matrixProjection(float mat[9], int width, int height, eTransform transform) {
+void matrixProjection(float mat[9], int width, int height, eTransform transform) {
     memset(mat, 0, sizeof(*mat) * 9);
 
     const float* t = transforms.at(transform).data();
@@ -219,3 +219,10 @@ void projectBox(float mat[9], CBox& box, eTransform transform, float rotation, c
 
     matrixMultiply(mat, projection, mat);
 }
+
+wl_output_transform invertTransform(wl_output_transform tr) {
+    if ((tr & WL_OUTPUT_TRANSFORM_90) && !(tr & WL_OUTPUT_TRANSFORM_FLIPPED))
+        tr = (wl_output_transform)(tr ^ (int)WL_OUTPUT_TRANSFORM_180);
+
+    return tr;
+}

src/helpers/math/Math.hpp

@@ -9,3 +9,12 @@ using namespace Hyprutils::Math;
 
 eTransform          wlTransformToHyprutils(wl_output_transform t);
 void                projectBox(float mat[9], CBox& box, eTransform transform, float rotation, const float projection[9]);
+void                matrixProjection(float mat[9], int width, int height, eTransform transform);
+void                matrixTransform(float mat[9], eTransform transform);
+void                matrixRotate(float mat[9], float rad);
+void                matrixScale(float mat[9], float x, float y);
+void                matrixTranslate(float mat[9], float x, float y);
+void                matrixTranspose(float mat[9], const float a[9]);
+void                matrixMultiply(float mat[9], const float a[9], const float b[9]);
+void                matrixIdentity(float mat[9]);
+wl_output_transform invertTransform(wl_output_transform tr);

src/includes.hpp

@@ -16,78 +16,6 @@
 #include <time.h>
 #include <unistd.h>
 #include <wayland-server-core.h>
-#include <mutex>
-#include <thread>
-#include <filesystem>
-#include <climits>
-
-#if true
-// wlroots uses dumb-ass shit that makes it not compile on C++, let's fix that.
-// https://github.com/swaywm/wlroots/issues/682
-// pthread first because it uses class in a C++ way and XWayland includes that...
-#include <pthread.h>
-
-#define class     _class
-#define namespace _namespace
-#define static
-#define delete delete_
-
-extern "C" {
-#include <wlr/backend.h>
-#include <wlr/backend/libinput.h>
-#include <wlr/backend/drm.h>
-#include <wlr/render/allocator.h>
-#include <wlr/render/wlr_renderer.h>
-#include <wlr/types/wlr_compositor.h>
-#include <wlr/types/wlr_data_control_v1.h>
-#include <wlr/types/wlr_data_device.h>
-#include <wlr/types/wlr_drm_lease_v1.h>
-#include <wlr/types/wlr_drm.h>
-#include <wlr/types/wlr_linux_dmabuf_v1.h>
-#include <wlr/types/wlr_input_device.h>
-#include <wlr/types/wlr_keyboard.h>
-#include <wlr/types/wlr_matrix.h>
-#include <wlr/types/wlr_output.h>
-#include <wlr/types/wlr_pointer.h>
-#include <wlr/types/wlr_primary_selection.h>
-#include <wlr/types/wlr_primary_selection_v1.h>
-#include <wlr/types/wlr_viewporter.h>
-#include <wlr/types/wlr_subcompositor.h>
-#include <wlr/util/log.h>
-#include <wlr/util/region.h>
-#include <wlr/util/edges.h>
-#include <wlr/types/wlr_tablet_pad.h>
-#include <wlr/types/wlr_tablet_tool.h>
-#include <xkbcommon/xkbcommon.h>
-#include <wlr/render/egl.h>
-#include <wlr/render/gles2.h>
-#include <wlr/render/wlr_texture.h>
-#include <wlr/interfaces/wlr_keyboard.h>
-#include <wlr/interfaces/wlr_pointer.h>
-#include <wlr/types/wlr_touch.h>
-#include <wlr/types/wlr_switch.h>
-#include <wlr/config.h>
-#include <wlr/backend/headless.h>
-#include <wlr/backend/multi.h>
-#include <wlr/backend/wayland.h>
-#include <wlr/types/wlr_single_pixel_buffer_v1.h>
-#include <wlr/util/box.h>
-#include <wlr/util/transform.h>
-#include <wlr/render/swapchain.h>
-#include <wlr/render/egl.h>
-
-#include <libdrm/drm_fourcc.h>
-
-#if WLR_HAS_X11_BACKEND
-#include <wlr/backend/x11.h>
-#endif
-}
-
-#undef delete
-#undef class
-#undef namespace
-#undef static
-#endif
 
 #ifdef LEGACY_RENDERER
 #include <GLES2/gl2.h>

src/managers/CursorManager.cpp

@@ -3,10 +3,10 @@
 #include "../config/ConfigValue.hpp"
 #include "PointerManager.hpp"
 #include "../xwayland/XWayland.hpp"
+#include <cstring>
 
 extern "C" {
-#include <wlr/interfaces/wlr_buffer.h>
+#include <X11/Xcursor/Xcursor.h>
-#include <wlr/types/wlr_xcursor_manager.h>
 }
 
 static int cursorAnimTimer(void* data) {
@@ -45,8 +45,7 @@ CCursorManager::CCursorManager() {
     if (m_iSize == 0)
         m_iSize = 24;
 
-    m_pWLRXCursorMgr = wlr_xcursor_manager_create(getenv("XCURSOR_THEME"), m_iSize);
+    xcursor.loadTheme(getenv("XCURSOR_THEME") ? getenv("XCURSOR_THEME") : "", m_iSize * std::ceil(m_fCursorScale));
-    wlr_xcursor_manager_load(m_pWLRXCursorMgr, 1.0);
 
     m_pAnimationTimer = wl_event_loop_add_timer(g_pCompositor->m_sWLEventLoop, ::cursorAnimTimer, nullptr);
 
@@ -56,9 +55,6 @@ CCursorManager::CCursorManager() {
 }
 
 CCursorManager::~CCursorManager() {
-    if (m_pWLRXCursorMgr)
-        wlr_xcursor_manager_destroy(m_pWLRXCursorMgr);
-
     if (m_pAnimationTimer)
         wl_event_source_remove(m_pAnimationTimer);
 }
@@ -134,32 +130,19 @@ void CCursorManager::setCursorSurface(SP<CWLSurface> surf, const Vector2D& hotsp
 }
 
 void CCursorManager::setXCursor(const std::string& name) {
-    if (!m_pWLRXCursorMgr) {
-        g_pPointerManager->resetCursorImage();
-        return;
-    }
-
     float scale = std::ceil(m_fCursorScale);
-    wlr_xcursor_manager_load(m_pWLRXCursorMgr, scale);
+    xcursor.loadTheme(name.c_str(), m_iSize * scale);
 
-    auto xcursor = wlr_xcursor_manager_get_xcursor(m_pWLRXCursorMgr, name.c_str(), scale);
+    if (!xcursor.themeLoaded) {
-    if (!xcursor) {
+        Debug::log(ERR, "XCursor failed to find theme in setXCursor");
-        Debug::log(ERR, "XCursor has no shape {}, retrying with left-ptr", name);
-        xcursor = wlr_xcursor_manager_get_xcursor(m_pWLRXCursorMgr, "left-ptr", scale);
-    }
-
-    if (!xcursor || !xcursor->images[0]) {
-        Debug::log(ERR, "XCursor is broken. F this garbage.");
         g_pPointerManager->resetCursorImage();
         return;
     }
 
-    auto image = xcursor->images[0];
-
     m_vCursorBuffers.emplace_back(
-        makeShared<CCursorBuffer>(image->buffer, Vector2D{(int)image->width, (int)image->height}, Vector2D{(double)image->hotspot_x, (double)image->hotspot_y}));
+        makeShared<CCursorBuffer>(xcursor.defaultCursor->pixels.data(), xcursor.defaultCursor->size, xcursor.defaultCursor->hotspot));
 
-    g_pPointerManager->setCursorBuffer(getCursorBuffer(), Vector2D{(double)image->hotspot_x, (double)image->hotspot_y} / scale, scale);
+    g_pPointerManager->setCursorBuffer(getCursorBuffer(), xcursor.defaultCursor->hotspot / scale, scale);
     if (m_vCursorBuffers.size() > 1)
         dropBufferRef(m_vCursorBuffers.at(0).get());
 
@@ -263,10 +246,9 @@ void CCursorManager::setXWaylandCursor() {
     if (CURSOR.surface) {
         g_pXWayland->setCursor(cairo_image_surface_get_data(CURSOR.surface), cairo_image_surface_get_stride(CURSOR.surface), {CURSOR.size, CURSOR.size},
                                {CURSOR.hotspotX, CURSOR.hotspotY});
-    } else if (const auto XCURSOR = wlr_xcursor_manager_get_xcursor(m_pWLRXCursorMgr, "left_ptr", 1); XCURSOR) {
+    } else if (xcursor.themeLoaded)
-        g_pXWayland->setCursor(XCURSOR->images[0]->buffer, XCURSOR->images[0]->width * 4, {(int)XCURSOR->images[0]->width, (int)XCURSOR->images[0]->height},
+        g_pXWayland->setCursor(xcursor.defaultCursor->pixels.data(), xcursor.defaultCursor->size.x * 4, xcursor.defaultCursor->size, xcursor.defaultCursor->hotspot);
-                               {(double)XCURSOR->images[0]->hotspot_x, (double)XCURSOR->images[0]->hotspot_y});
+    else
-    } else
         Debug::log(ERR, "CursorManager: no valid cursor for xwayland");
 }
 
@@ -310,37 +292,36 @@ bool CCursorManager::changeTheme(const std::string& name, const int size) {
 
     Debug::log(ERR, "Hyprcursor failed loading theme \"{}\", falling back to X.", name);
 
-    if (m_pWLRXCursorMgr)
+    xcursor.loadTheme(name, size);
-        wlr_xcursor_manager_destroy(m_pWLRXCursorMgr);
 
-    m_pWLRXCursorMgr = wlr_xcursor_manager_create(name.empty() ? "" : name.c_str(), size);
-    bool xSuccess    = wlr_xcursor_manager_load(m_pWLRXCursorMgr, 1.0) == 1;
-
-    // this basically checks if xcursor changed used theme to default but better
-    bool                       diffTheme = false;
-    wlr_xcursor_manager_theme* theme;
-    wl_list_for_each(theme, &m_pWLRXCursorMgr->scaled_themes, link) {
-        if (std::string{theme->theme->name} != name) {
-            diffTheme = true;
-            break;
-        }
-    }
-
-    if (xSuccess && !diffTheme) {
     m_szTheme = name;
     m_iSize   = size;
     updateTheme();
     return true;
+}
+
+void CCursorManager::SXCursorManager::loadTheme(const std::string& name, int size) {
+    themeLoaded = false;
+    themeName   = name.empty() ? "default" : name;
+
+    auto img = XcursorShapeLoadImage(1, name.c_str(), size);
+
+    if (!img) {
+        Debug::log(ERR, "XCursor failed finding theme \"{}\". Trying size 24.", name);
+        size = 24;
+        img  = XcursorShapeLoadImage(1, name.c_str(), size);
+        if (!img) {
+            Debug::log(ERR, "XCursor failed finding theme \"{}\".", name);
+            return;
+        }
     }
 
-    Debug::log(ERR, "X also failed loading theme \"{}\", falling back to previous theme.", name);
+    defaultCursor          = makeShared<SXCursor>();
+    defaultCursor->size    = {(int)img->width, (int)img->height};
+    defaultCursor->hotspot = {(int)img->xhot, (int)img->yhot};
 
-    m_pHyprcursor = std::make_unique<Hyprcursor::CHyprcursorManager>(m_szTheme.c_str(), hcLogger);
+    defaultCursor->pixels.resize(img->width * img->height);
+    std::memcpy(defaultCursor->pixels.data(), img->pixels, img->width * img->height);
 
-    wlr_xcursor_manager_destroy(m_pWLRXCursorMgr);
+    themeLoaded = true;
-    m_pWLRXCursorMgr = wlr_xcursor_manager_create(m_szTheme.c_str(), m_iSize);
-    wlr_xcursor_manager_load(m_pWLRXCursorMgr, 1.0);
-
-    updateTheme();
-    return false;
 }

src/managers/CursorManager.hpp

@@ -7,7 +7,6 @@
 #include "../helpers/math/Math.hpp"
 #include "../helpers/memory/Memory.hpp"
 
-struct wlr_xcursor_manager;
 class CWLSurface;
 
 AQUAMARINE_FORWARD(IBuffer);
@@ -73,8 +72,21 @@ class CCursorManager {
     int                                             m_iCurrentAnimationFrame = 0;
     Hyprcursor::SCursorShapeData                    m_sCurrentCursorShapeData;
 
-    // xcursor fallback
+    // gangsta bootleg XCursor impl. Whenever Hyprland has to use
-    wlr_xcursor_manager* m_pWLRXCursorMgr = nullptr;
+    // an xcursor, just use the pointer.
+    struct SXCursor {
+        Vector2D             size;
+        Vector2D             hotspot;
+        std::vector<uint8_t> pixels;
+    };
+
+    struct SXCursorManager {
+        void         loadTheme(const std::string& name, int size);
+
+        bool         themeLoaded = false;
+        std::string  themeName   = "";
+        SP<SXCursor> defaultCursor;
+    } xcursor;
 };
 
 inline std::unique_ptr<CCursorManager> g_pCursorManager;

src/managers/KeybindManager.cpp

@@ -4,6 +4,7 @@
 #include "../protocols/LayerShell.hpp"
 #include "../protocols/ShortcutsInhibit.hpp"
 #include "../render/decorations/CHyprGroupBarDecoration.hpp"
+#include "../devices/IKeyboard.hpp"
 #include "KeybindManager.hpp"
 #include "PointerManager.hpp"
 #include "Compositor.hpp"
@@ -15,6 +16,7 @@
 #include <iterator>
 #include <string>
 #include <string_view>
+#include <cstring>
 
 #include <hyprutils/string/String.hpp>
 using namespace Hyprutils::String;
@@ -157,37 +159,37 @@ uint32_t CKeybindManager::stringToModMask(std::string mods) {
     uint32_t modMask = 0;
     std::transform(mods.begin(), mods.end(), mods.begin(), ::toupper);
     if (mods.contains("SHIFT"))
-        modMask |= WLR_MODIFIER_SHIFT;
+        modMask |= HL_MODIFIER_SHIFT;
     if (mods.contains("CAPS"))
-        modMask |= WLR_MODIFIER_CAPS;
+        modMask |= HL_MODIFIER_CAPS;
     if (mods.contains("CTRL") || mods.contains("CONTROL"))
-        modMask |= WLR_MODIFIER_CTRL;
+        modMask |= HL_MODIFIER_CTRL;
     if (mods.contains("ALT") || mods.contains("MOD1"))
-        modMask |= WLR_MODIFIER_ALT;
+        modMask |= HL_MODIFIER_ALT;
     if (mods.contains("MOD2"))
-        modMask |= WLR_MODIFIER_MOD2;
+        modMask |= HL_MODIFIER_MOD2;
     if (mods.contains("MOD3"))
-        modMask |= WLR_MODIFIER_MOD3;
+        modMask |= HL_MODIFIER_MOD3;
-    if (mods.contains("SUPER") || mods.contains("WIN") || mods.contains("LOGO") || mods.contains("MOD4"))
+    if (mods.contains("SUPER") || mods.contains("WIN") || mods.contains("LOGO") || mods.contains("MOD4") || mods.contains("META"))
-        modMask |= WLR_MODIFIER_LOGO;
+        modMask |= HL_MODIFIER_META;
     if (mods.contains("MOD5"))
-        modMask |= WLR_MODIFIER_MOD5;
+        modMask |= HL_MODIFIER_MOD5;
 
     return modMask;
 }
 
 uint32_t CKeybindManager::keycodeToModifier(xkb_keycode_t keycode) {
     switch (keycode - 8) {
-        case KEY_LEFTMETA: return WLR_MODIFIER_LOGO;
+        case KEY_LEFTMETA: return HL_MODIFIER_META;
-        case KEY_RIGHTMETA: return WLR_MODIFIER_LOGO;
+        case KEY_RIGHTMETA: return HL_MODIFIER_META;
-        case KEY_LEFTSHIFT: return WLR_MODIFIER_SHIFT;
+        case KEY_LEFTSHIFT: return HL_MODIFIER_SHIFT;
-        case KEY_RIGHTSHIFT: return WLR_MODIFIER_SHIFT;
+        case KEY_RIGHTSHIFT: return HL_MODIFIER_SHIFT;
-        case KEY_LEFTCTRL: return WLR_MODIFIER_CTRL;
+        case KEY_LEFTCTRL: return HL_MODIFIER_CTRL;
-        case KEY_RIGHTCTRL: return WLR_MODIFIER_CTRL;
+        case KEY_RIGHTCTRL: return HL_MODIFIER_CTRL;
-        case KEY_LEFTALT: return WLR_MODIFIER_ALT;
+        case KEY_LEFTALT: return HL_MODIFIER_ALT;
-        case KEY_RIGHTALT: return WLR_MODIFIER_ALT;
+        case KEY_RIGHTALT: return HL_MODIFIER_ALT;
-        case KEY_CAPSLOCK: return WLR_MODIFIER_CAPS;
+        case KEY_CAPSLOCK: return HL_MODIFIER_CAPS;
-        case KEY_NUMLOCK: return WLR_MODIFIER_MOD2;
+        case KEY_NUMLOCK: return HL_MODIFIER_MOD2;
         default: return 0;
     }
 }

src/managers/KeybindManager.hpp

@@ -6,6 +6,7 @@
 #include "../Compositor.hpp"
 #include <unordered_map>
 #include <functional>
+#include <xkbcommon/xkbcommon.h>
 #include "../devices/IPointer.hpp"
 
 class CInputManager;

src/managers/PointerManager.cpp

@@ -6,9 +6,6 @@
 #include "../protocols/core/Compositor.hpp"
 #include "eventLoop/EventLoopManager.hpp"
 #include "SeatManager.hpp"
-#include <wlr/interfaces/wlr_output.h>
-#include <wlr/render/interface.h>
-#include <wlr/render/wlr_renderer.h>
 
 CPointerManager::CPointerManager() {
     hooks.monitorAdded = g_pHookSystem->hookDynamic("newMonitor", [this](void* self, SCallbackInfo& info, std::any data) {
@@ -465,7 +462,7 @@ Vector2D CPointerManager::transformedHotspot(SP<CMonitor> pMonitor) {
         return {}; // doesn't matter, we have no hw cursor, and this is only for hw cursors
 
     return CBox{currentCursorImage.hotspot * pMonitor->scale, {0, 0}}
-        .transform(wlTransformToHyprutils(wlr_output_transform_invert(pMonitor->transform)), pMonitor->cursorSwapchain->currentOptions().size.x,
+        .transform(wlTransformToHyprutils(invertTransform(pMonitor->transform)), pMonitor->cursorSwapchain->currentOptions().size.x,
                    pMonitor->cursorSwapchain->currentOptions().size.y)
         .pos();
 }

src/managers/ProtocolManager.cpp

@@ -131,7 +131,14 @@ CProtocolManager::CProtocolManager() {
     PROTO::dataWlr             = std::make_unique<CDataDeviceWLRProtocol>(&zwlr_data_control_manager_v1_interface, 2, "DataDeviceWlr");
     PROTO::primarySelection    = std::make_unique<CPrimarySelectionProtocol>(&zwp_primary_selection_device_manager_v1_interface, 1, "PrimarySelection");
     PROTO::xwaylandShell       = std::make_unique<CXWaylandShellProtocol>(&xwayland_shell_v1_interface, 1, "XWaylandShell");
+
+    for (auto& b : g_pCompositor->m_pAqBackend->getImplementations()) {
+        if (b->type() != Aquamarine::AQ_BACKEND_DRM)
+            continue;
+
         PROTO::lease = std::make_unique<CDRMLeaseProtocol>(&wp_drm_lease_device_v1_interface, 1, "DRMLease");
+        break;
+    }
 
     if (g_pHyprOpenGL->getDRMFormats().size() > 0) {
         PROTO::mesaDRM  = std::make_unique<CMesaDRMProtocol>(&wl_drm_interface, 2, "MesaDRM");

src/protocols/DRMLease.cpp

@@ -248,7 +248,6 @@ CDRMLeaseProtocol::CDRMLeaseProtocol(const wl_interface* iface, const int& ver,
     }
 
     if (!primaryDevice || primaryDevice->success) {
-        LOGM(ERR, "No DRM backend, not creating lease");
         PROTO::lease.reset();
         return;
     }

src/protocols/InputMethodV2.cpp

@@ -4,6 +4,7 @@
 #include "../devices/IKeyboard.hpp"
 #include <sys/mman.h>
 #include "core/Compositor.hpp"
+#include <cstring>
 
 #define LOGM PROTO::ime->protoLog
 

src/protocols/LinuxDMABUF.cpp

@@ -6,6 +6,7 @@
 #include <sys/mman.h>
 #include <xf86drm.h>
 #include <fcntl.h>
+#include <sys/stat.h>
 #include "core/Compositor.hpp"
 #include "types/DMABuffer.hpp"
 #include "types/WLBuffer.hpp"

src/protocols/PresentationTime.cpp

@@ -4,6 +4,7 @@
 #include "../managers/HookSystemManager.hpp"
 #include "core/Compositor.hpp"
 #include "core/Output.hpp"
+#include <aquamarine/output/Output.hpp>
 
 #define LOGM PROTO::presentation->protoLog
 
@@ -54,9 +55,9 @@ void CPresentationFeedback::sendQueued(SP<CQueuedPresentationData> data, timespe
         flags |= WP_PRESENTATION_FEEDBACK_KIND_VSYNC;
     if (data->zeroCopy)
         flags |= WP_PRESENTATION_FEEDBACK_KIND_ZERO_COPY;
-    if (reportedFlags & WLR_OUTPUT_PRESENT_HW_CLOCK)
+    if (reportedFlags & Aquamarine::IOutput::AQ_OUTPUT_PRESENT_HW_CLOCK)
         flags |= WP_PRESENTATION_FEEDBACK_KIND_HW_CLOCK;
-    if (reportedFlags & WLR_OUTPUT_PRESENT_HW_COMPLETION)
+    if (reportedFlags & Aquamarine::IOutput::AQ_OUTPUT_PRESENT_HW_COMPLETION)
         flags |= WP_PRESENTATION_FEEDBACK_KIND_HW_COMPLETION;
 
     if (data->wasPresented)

src/protocols/Screencopy.cpp

@@ -542,7 +542,7 @@ bool CScreencopyProtocolManager::copyFrameDmabuf(SScreencopyFrame* frame) {
 
     CBox monbox = CBox{0, 0, frame->pMonitor->vecPixelSize.x, frame->pMonitor->vecPixelSize.y}
                       .translate({-frame->box.x, -frame->box.y}) // vvvv kinda ass-backwards but that's how I designed the renderer... sigh.
-                      .transform(wlTransformToHyprutils(wlr_output_transform_invert(frame->pMonitor->transform)), frame->pMonitor->vecPixelSize.x, frame->pMonitor->vecPixelSize.y);
+                      .transform(wlTransformToHyprutils(invertTransform(frame->pMonitor->transform)), frame->pMonitor->vecPixelSize.x, frame->pMonitor->vecPixelSize.y);
     g_pHyprOpenGL->setMonitorTransformEnabled(true);
     g_pHyprOpenGL->setRenderModifEnabled(false);
     g_pHyprOpenGL->renderTexture(TEXTURE, &monbox, 1);

src/protocols/Tablet.cpp

@@ -5,6 +5,7 @@
 #include "core/Seat.hpp"
 #include "core/Compositor.hpp"
 #include <algorithm>
+#include <cstring>
 
 #define LOGM PROTO::tablet->protoLog
 

src/protocols/XDGShell.cpp

@@ -4,6 +4,7 @@
 #include "../managers/SeatManager.hpp"
 #include "core/Seat.hpp"
 #include "core/Compositor.hpp"
+#include <cstring>
 
 #define LOGM PROTO::xdgShell->protoLog
 

src/protocols/core/Compositor.cpp

@@ -426,7 +426,7 @@ CRegion CWLSurfaceResource::accumulateCurrentBufferDamage() {
 
     Vector2D trc = current.transform % 2 == 1 ? Vector2D{current.buffer->size.y, current.buffer->size.x} : current.buffer->size;
 
-    return surfaceDamage.scale(current.scale).transform(wlTransformToHyprutils(wlr_output_transform_invert(current.transform)), trc.x, trc.y).add(current.bufferDamage);
+    return surfaceDamage.scale(current.scale).transform(wlTransformToHyprutils(invertTransform(current.transform)), trc.x, trc.y).add(current.bufferDamage);
 }
 
 CWLCompositorResource::CWLCompositorResource(SP<CWlCompositor> resource_) : resource(resource_) {

src/render/OpenGL.cpp

@@ -58,23 +58,20 @@ static void eglLog(EGLenum error, const char* command, EGLint type, EGLLabelKHR
 }
 
 static int openRenderNode(int drmFd) {
-    char* renderName = drmGetRenderDeviceNameFromFd(drmFd);
+    auto renderName = drmGetRenderDeviceNameFromFd(drmFd);
-    if (renderName == NULL) {
+    if (!renderName) {
         // This can happen on split render/display platforms, fallback to
         // primary node
         renderName = drmGetPrimaryDeviceNameFromFd(drmFd);
-        if (renderName == NULL) {
+        if (!renderName) {
-            wlr_log_errno(WLR_ERROR, "drmGetPrimaryDeviceNameFromFd failed");
+            Debug::log(ERR, "drmGetPrimaryDeviceNameFromFd failed");
             return -1;
         }
-        wlr_log(WLR_DEBUG,
+        Debug::log(LOG, "DRM dev {} has no render node, falling back to primary", renderName);
-                "DRM device '%s' has no render node, "
-                "falling back to primary node",
-                renderName);
 
         drmVersion* render_version = drmGetVersion(drmFd);
-        if (render_version != NULL && render_version->name != NULL) {
+        if (render_version && render_version->name) {
-            wlr_log(WLR_DEBUG, "DRM device version.name '%s'", render_version->name);
+            Debug::log(LOG, "DRM dev versionName", render_version->name);
             if (strcmp(render_version->name, "evdi") == 0) {
                 free(renderName);
                 renderName = (char*)malloc(sizeof(char) * 15);
@@ -84,14 +81,14 @@ static int openRenderNode(int drmFd) {
         }
     }
 
-    wlr_log(WLR_DEBUG, "open_render_node() DRM device '%s'", renderName);
+    Debug::log(LOG, "openRenderNode got drm device {}", renderName);
+
+    int renderFD = open(renderName, O_RDWR | O_CLOEXEC);
+    if (renderFD < 0)
+        Debug::log(ERR, "openRenderNode failed to open drm device {}", renderName);
 
-    int render_fd = open(renderName, O_RDWR | O_CLOEXEC);
-    if (render_fd < 0) {
-        wlr_log_errno(WLR_ERROR, "Failed to open DRM node '%s'", renderName);
-    }
     free(renderName);
-    return render_fd;
+    return renderFD;
 }
 
 void CHyprOpenGLImpl::initEGL(bool gbm) {
@@ -323,7 +320,7 @@ void CHyprOpenGLImpl::initDRMFormats() {
         return;
     }
 
-    wlr_log(WLR_DEBUG, "Supported DMA-BUF formats:");
+    Debug::log(LOG, "Supported DMA-BUF formats:");
 
     std::vector<SDRMFormat> dmaFormats;
 
@@ -646,12 +643,12 @@ void CHyprOpenGLImpl::beginSimple(CMonitor* pMonitor, const CRegion& damage, CRe
 
     matrixProjection(m_RenderData.projection, pMonitor->vecPixelSize.x, pMonitor->vecPixelSize.y, WL_OUTPUT_TRANSFORM_NORMAL);
 
-    wlr_matrix_identity(m_RenderData.monitorProjection.data());
+    matrixIdentity(m_RenderData.monitorProjection.data());
     if (pMonitor->transform != WL_OUTPUT_TRANSFORM_NORMAL) {
         const Vector2D tfmd = pMonitor->transform % 2 == 1 ? Vector2D{FBO->m_vSize.y, FBO->m_vSize.x} : FBO->m_vSize;
-        wlr_matrix_translate(m_RenderData.monitorProjection.data(), FBO->m_vSize.x / 2.0, FBO->m_vSize.y / 2.0);
+        matrixTranslate(m_RenderData.monitorProjection.data(), FBO->m_vSize.x / 2.0, FBO->m_vSize.y / 2.0);
-        wlr_matrix_transform(m_RenderData.monitorProjection.data(), pMonitor->transform);
+        matrixTransform(m_RenderData.monitorProjection.data(), wlTransformToHyprutils(pMonitor->transform));
-        wlr_matrix_translate(m_RenderData.monitorProjection.data(), -tfmd.x / 2.0, -tfmd.y / 2.0);
+        matrixTranslate(m_RenderData.monitorProjection.data(), -tfmd.x / 2.0, -tfmd.y / 2.0);
     }
 
     m_RenderData.pCurrentMonData = &m_mMonitorRenderResources[pMonitor];
@@ -1087,7 +1084,7 @@ void CHyprOpenGLImpl::scissor(const CBox* pBox, bool transform) {
     CBox newBox = *pBox;
 
     if (transform) {
-        const auto TR = wlTransformToHyprutils(wlr_output_transform_invert(m_RenderData.pMonitor->transform));
+        const auto TR = wlTransformToHyprutils(invertTransform(m_RenderData.pMonitor->transform));
         newBox.transform(TR, m_RenderData.pMonitor->vecTransformedSize.x, m_RenderData.pMonitor->vecTransformedSize.y);
     }
 
@@ -1177,11 +1174,11 @@ void CHyprOpenGLImpl::renderRectWithDamage(CBox* box, const CColor& col, CRegion
     box = &newBox;
 
     float matrix[9];
-    projectBox(matrix, newBox, wlTransformToHyprutils(wlr_output_transform_invert(!m_bEndFrame ? WL_OUTPUT_TRANSFORM_NORMAL : m_RenderData.pMonitor->transform)), newBox.rot,
+    projectBox(matrix, newBox, wlTransformToHyprutils(invertTransform(!m_bEndFrame ? WL_OUTPUT_TRANSFORM_NORMAL : m_RenderData.pMonitor->transform)), newBox.rot,
                m_RenderData.monitorProjection.data()); // TODO: write own, don't use WLR here
 
     float glMatrix[9];
-    wlr_matrix_multiply(glMatrix, m_RenderData.projection, matrix);
+    matrixMultiply(glMatrix, m_RenderData.projection, matrix);
 
     glUseProgram(m_RenderData.pCurrentMonData->m_shQUAD.program);
 
@@ -1196,7 +1193,7 @@ void CHyprOpenGLImpl::renderRectWithDamage(CBox* box, const CColor& col, CRegion
     glUniform4f(m_RenderData.pCurrentMonData->m_shQUAD.color, col.r * col.a, col.g * col.a, col.b * col.a, col.a);
 
     CBox transformedBox = *box;
-    transformedBox.transform(wlTransformToHyprutils(wlr_output_transform_invert(m_RenderData.pMonitor->transform)), m_RenderData.pMonitor->vecTransformedSize.x,
+    transformedBox.transform(wlTransformToHyprutils(invertTransform(m_RenderData.pMonitor->transform)), m_RenderData.pMonitor->vecTransformedSize.x,
                              m_RenderData.pMonitor->vecTransformedSize.y);
 
     const auto TOPLEFT  = Vector2D(transformedBox.x, transformedBox.y);
@@ -1268,12 +1265,12 @@ void CHyprOpenGLImpl::renderTextureInternalWithDamage(SP<CTexture> tex, CBox* pB
     static auto PDT          = CConfigValue<Hyprlang::INT>("debug:damage_tracking");
 
     // get transform
-    const auto TRANSFORM = wlTransformToHyprutils(wlr_output_transform_invert(!m_bEndFrame ? WL_OUTPUT_TRANSFORM_NORMAL : m_RenderData.pMonitor->transform));
+    const auto TRANSFORM = wlTransformToHyprutils(invertTransform(!m_bEndFrame ? WL_OUTPUT_TRANSFORM_NORMAL : m_RenderData.pMonitor->transform));
     float      matrix[9];
     projectBox(matrix, newBox, TRANSFORM, newBox.rot, m_RenderData.monitorProjection.data());
 
     float glMatrix[9];
-    wlr_matrix_multiply(glMatrix, m_RenderData.projection, matrix);
+    matrixMultiply(glMatrix, m_RenderData.projection, matrix);
 
     CShader*   shader = nullptr;
 
@@ -1356,7 +1353,7 @@ void CHyprOpenGLImpl::renderTextureInternalWithDamage(SP<CTexture> tex, CBox* pB
     }
 
     CBox transformedBox = newBox;
-    transformedBox.transform(wlTransformToHyprutils(wlr_output_transform_invert(m_RenderData.pMonitor->transform)), m_RenderData.pMonitor->vecTransformedSize.x,
+    transformedBox.transform(wlTransformToHyprutils(invertTransform(m_RenderData.pMonitor->transform)), m_RenderData.pMonitor->vecTransformedSize.x,
                              m_RenderData.pMonitor->vecTransformedSize.y);
 
     const auto TOPLEFT  = Vector2D(transformedBox.x, transformedBox.y);
@@ -1431,12 +1428,12 @@ void CHyprOpenGLImpl::renderTexturePrimitive(SP<CTexture> tex, CBox* pBox) {
     m_RenderData.renderModif.applyToBox(newBox);
 
     // get transform
-    const auto TRANSFORM = wlTransformToHyprutils(wlr_output_transform_invert(!m_bEndFrame ? WL_OUTPUT_TRANSFORM_NORMAL : m_RenderData.pMonitor->transform));
+    const auto TRANSFORM = wlTransformToHyprutils(invertTransform(!m_bEndFrame ? WL_OUTPUT_TRANSFORM_NORMAL : m_RenderData.pMonitor->transform));
     float      matrix[9];
     projectBox(matrix, newBox, TRANSFORM, newBox.rot, m_RenderData.monitorProjection.data());
 
     float glMatrix[9];
-    wlr_matrix_multiply(glMatrix, m_RenderData.projection, matrix);
+    matrixMultiply(glMatrix, m_RenderData.projection, matrix);
 
     CShader* shader = &m_RenderData.pCurrentMonData->m_shPASSTHRURGBA;
 
@@ -1485,12 +1482,12 @@ void CHyprOpenGLImpl::renderTextureMatte(SP<CTexture> tex, CBox* pBox, CFramebuf
     m_RenderData.renderModif.applyToBox(newBox);
 
     // get transform
-    const auto TRANSFORM = wlTransformToHyprutils(wlr_output_transform_invert(!m_bEndFrame ? WL_OUTPUT_TRANSFORM_NORMAL : m_RenderData.pMonitor->transform));
+    const auto TRANSFORM = wlTransformToHyprutils(invertTransform(!m_bEndFrame ? WL_OUTPUT_TRANSFORM_NORMAL : m_RenderData.pMonitor->transform));
     float      matrix[9];
     projectBox(matrix, newBox, TRANSFORM, newBox.rot, m_RenderData.monitorProjection.data());
 
     float glMatrix[9];
-    wlr_matrix_multiply(glMatrix, m_RenderData.projection, matrix);
+    matrixMultiply(glMatrix, m_RenderData.projection, matrix);
 
     CShader* shader = &m_RenderData.pCurrentMonData->m_shMATTE;
 
@@ -1543,13 +1540,13 @@ CFramebuffer* CHyprOpenGLImpl::blurMainFramebufferWithDamage(float a, CRegion* o
     glDisable(GL_STENCIL_TEST);
 
     // get transforms for the full monitor
-    const auto TRANSFORM = wlTransformToHyprutils(wlr_output_transform_invert(m_RenderData.pMonitor->transform));
+    const auto TRANSFORM = wlTransformToHyprutils(invertTransform(m_RenderData.pMonitor->transform));
     float      matrix[9];
     CBox       MONITORBOX = {0, 0, m_RenderData.pMonitor->vecTransformedSize.x, m_RenderData.pMonitor->vecTransformedSize.y};
     projectBox(matrix, MONITORBOX, TRANSFORM, 0, m_RenderData.monitorProjection.data());
 
     float glMatrix[9];
-    wlr_matrix_multiply(glMatrix, m_RenderData.projection, matrix);
+    matrixMultiply(glMatrix, m_RenderData.projection, matrix);
 
     // get the config settings
     static auto PBLURSIZE             = CConfigValue<Hyprlang::INT>("decoration:blur:size");
@@ -1559,9 +1556,8 @@ CFramebuffer* CHyprOpenGLImpl::blurMainFramebufferWithDamage(float a, CRegion* o
 
     // prep damage
     CRegion damage{*originalDamage};
-    wlr_region_transform(damage.pixman(), damage.pixman(), wlr_output_transform_invert(m_RenderData.pMonitor->transform), m_RenderData.pMonitor->vecTransformedSize.x,
+    damage.transform(wlTransformToHyprutils(invertTransform(m_RenderData.pMonitor->transform)), m_RenderData.pMonitor->vecTransformedSize.x, m_RenderData.pMonitor->vecTransformedSize.y);
-                         m_RenderData.pMonitor->vecTransformedSize.y);
+    damage.expand(*PBLURPASSES > 10 ? pow(2, 15) : std::clamp(*PBLURSIZE, (int64_t)1, (int64_t)40) * pow(2, *PBLURPASSES));
-    wlr_region_expand(damage.pixman(), damage.pixman(), *PBLURPASSES > 10 ? pow(2, 15) : std::clamp(*PBLURSIZE, (int64_t)1, (int64_t)40) * pow(2, *PBLURPASSES));
 
     // helper
     const auto    PMIRRORFB     = &m_RenderData.pCurrentMonData->mirrorFB;
@@ -1680,12 +1676,12 @@ CFramebuffer* CHyprOpenGLImpl::blurMainFramebufferWithDamage(float a, CRegion* o
 
     // and draw
     for (int i = 1; i <= *PBLURPASSES; ++i) {
-        wlr_region_scale(tempDamage.pixman(), damage.pixman(), 1.f / (1 << i));
+        tempDamage.scale(1.f / (1 << i));
         drawPass(&m_RenderData.pCurrentMonData->m_shBLUR1, &tempDamage); // down
     }
 
     for (int i = *PBLURPASSES - 1; i >= 0; --i) {
-        wlr_region_scale(tempDamage.pixman(), damage.pixman(), 1.f / (1 << i)); // when upsampling we make the region twice as big
+        tempDamage.scale(1.f / (1 << i));                                // when upsampling we make the region twice as big
         drawPass(&m_RenderData.pCurrentMonData->m_shBLUR2, &tempDamage); // up
     }
 
@@ -1942,7 +1938,7 @@ void CHyprOpenGLImpl::renderTextureWithBlur(SP<CTexture> tex, CBox* pBox, float
         inverseOpaque = {0, 0, pBox->width, pBox->height};
     }
 
-    wlr_region_scale(inverseOpaque.pixman(), inverseOpaque.pixman(), m_RenderData.pMonitor->scale);
+    inverseOpaque.scale(m_RenderData.pMonitor->scale);
 
     //   vvv TODO: layered blur fbs?
     const bool    USENEWOPTIMIZE = shouldUseNewBlurOptimizations(m_pCurrentLayer, m_pCurrentWindow.lock()) && !blockBlurOptimization;
@@ -2041,11 +2037,11 @@ void CHyprOpenGLImpl::renderBorder(CBox* box, const CGradientValueData& grad, in
     round += round == 0 ? 0 : scaledBorderSize;
 
     float matrix[9];
-    projectBox(matrix, newBox, wlTransformToHyprutils(wlr_output_transform_invert(!m_bEndFrame ? WL_OUTPUT_TRANSFORM_NORMAL : m_RenderData.pMonitor->transform)), newBox.rot,
+    projectBox(matrix, newBox, wlTransformToHyprutils(invertTransform(!m_bEndFrame ? WL_OUTPUT_TRANSFORM_NORMAL : m_RenderData.pMonitor->transform)), newBox.rot,
                m_RenderData.monitorProjection.data()); // TODO: write own, don't use WLR here
 
     float glMatrix[9];
-    wlr_matrix_multiply(glMatrix, m_RenderData.projection, matrix);
+    matrixMultiply(glMatrix, m_RenderData.projection, matrix);
 
     const auto BLEND = m_bBlend;
     blend(true);
@@ -2067,7 +2063,7 @@ void CHyprOpenGLImpl::renderBorder(CBox* box, const CGradientValueData& grad, in
     glUniform1f(m_RenderData.pCurrentMonData->m_shBORDER1.alpha, a);
 
     CBox transformedBox = *box;
-    transformedBox.transform(wlTransformToHyprutils(wlr_output_transform_invert(m_RenderData.pMonitor->transform)), m_RenderData.pMonitor->vecTransformedSize.x,
+    transformedBox.transform(wlTransformToHyprutils(invertTransform(m_RenderData.pMonitor->transform)), m_RenderData.pMonitor->vecTransformedSize.x,
                              m_RenderData.pMonitor->vecTransformedSize.y);
 
     const auto TOPLEFT  = Vector2D(transformedBox.x, transformedBox.y);
@@ -2347,11 +2343,11 @@ void CHyprOpenGLImpl::renderRoundedShadow(CBox* box, int round, int range, const
     const auto  col = color;
 
     float       matrix[9];
-    projectBox(matrix, newBox, wlTransformToHyprutils(wlr_output_transform_invert(!m_bEndFrame ? WL_OUTPUT_TRANSFORM_NORMAL : m_RenderData.pMonitor->transform)), newBox.rot,
+    projectBox(matrix, newBox, wlTransformToHyprutils(invertTransform(!m_bEndFrame ? WL_OUTPUT_TRANSFORM_NORMAL : m_RenderData.pMonitor->transform)), newBox.rot,
                m_RenderData.monitorProjection.data()); // TODO: write own, don't use WLR here
 
     float glMatrix[9];
-    wlr_matrix_multiply(glMatrix, m_RenderData.projection, matrix);
+    matrixMultiply(glMatrix, m_RenderData.projection, matrix);
 
     glEnable(GL_BLEND);
 
@@ -2439,11 +2435,11 @@ void CHyprOpenGLImpl::renderMirrored() {
         return;
 
     // replace monitor projection to undo the mirrored monitor's projection
-    wlr_matrix_identity(monitor->projMatrix.data());
+    matrixIdentity(monitor->projMatrix.data());
-    wlr_matrix_translate(monitor->projMatrix.data(), monitor->vecPixelSize.x / 2.0, monitor->vecPixelSize.y / 2.0);
+    matrixTranslate(monitor->projMatrix.data(), monitor->vecPixelSize.x / 2.0, monitor->vecPixelSize.y / 2.0);
-    wlr_matrix_transform(monitor->projMatrix.data(), monitor->transform);
+    matrixTransform(monitor->projMatrix.data(), wlTransformToHyprutils(monitor->transform));
-    wlr_matrix_transform(monitor->projMatrix.data(), wlr_output_transform_invert(mirrored->transform));
+    matrixTransform(monitor->projMatrix.data(), wlTransformToHyprutils(invertTransform(mirrored->transform)));
-    wlr_matrix_translate(monitor->projMatrix.data(), -monitor->vecTransformedSize.x / 2.0, -monitor->vecTransformedSize.y / 2.0);
+    matrixTranslate(monitor->projMatrix.data(), -monitor->vecTransformedSize.x / 2.0, -monitor->vecTransformedSize.y / 2.0);
 
     // clear stuff outside of mirrored area (e.g. when changing to mirrored)
     clear(CColor(0, 0, 0, 0));
@@ -2672,8 +2668,8 @@ void CHyprOpenGLImpl::saveMatrix() {
 }
 
 void CHyprOpenGLImpl::setMatrixScaleTranslate(const Vector2D& translate, const float& scale) {
-    wlr_matrix_scale(m_RenderData.projection, scale, scale);
+    matrixScale(m_RenderData.projection, scale, scale);
-    wlr_matrix_translate(m_RenderData.projection, translate.x, translate.y);
+    matrixTranslate(m_RenderData.projection, translate.x, translate.y);
 }
 
 void CHyprOpenGLImpl::restoreMatrix() {

src/render/OpenGL.hpp

@@ -18,6 +18,8 @@
 #include "Transformer.hpp"
 #include "Renderbuffer.hpp"
 
+#include <EGL/egl.h>
+#include <EGL/eglext.h>
 #include <GLES2/gl2ext.h>
 #include <aquamarine/buffer/Buffer.hpp>
 

src/render/Renderbuffer.hpp

@@ -19,7 +19,7 @@ class CRenderbuffer {
     WP<Aquamarine::IBuffer> m_pHLBuffer;
 
   private:
-    EGLImageKHR  m_iImage = 0;
+    void*        m_iImage = nullptr;
     GLuint       m_iRBO   = 0;
     CFramebuffer m_sFramebuffer;
     uint32_t     m_uDrmFormat = 0;

src/render/Renderer.cpp

@@ -2,6 +2,7 @@
 #include "../Compositor.hpp"
 #include "../helpers/math/Math.hpp"
 #include <algorithm>
+#include <cstring>
 #include "../config/ConfigValue.hpp"
 #include "../managers/CursorManager.hpp"
 #include "../managers/PointerManager.hpp"
@@ -1316,11 +1317,11 @@ void CHyprRenderer::renderMonitor(CMonitor* pMonitor) {
                 *PBLURPASSES > 10 ? pow(2, 15) : std::clamp(*PBLURSIZE, (int64_t)1, (int64_t)40) * pow(2, *PBLURPASSES); // is this 2^pass? I don't know but it works... I think.
 
             // now, prep the damage, get the extended damage region
-            wlr_region_expand(damage.pixman(), damage.pixman(), BLURRADIUS); // expand for proper blurring
+            damage.expand(BLURRADIUS); // expand for proper blurring
 
             finalDamage = damage;
 
-            wlr_region_expand(damage.pixman(), damage.pixman(), BLURRADIUS); // expand for proper blurring 2
+            damage.expand(BLURRADIUS); // expand for proper blurring
         } else
             finalDamage = damage;
     }
@@ -1398,8 +1399,8 @@ void CHyprRenderer::renderMonitor(CMonitor* pMonitor) {
     if (!pMonitor->mirrors.empty()) {
         CRegion    frameDamage{};
 
-        const auto TRANSFORM = wlr_output_transform_invert(pMonitor->transform);
+        const auto TRANSFORM = invertTransform(pMonitor->transform);
-        wlr_region_transform(frameDamage.pixman(), finalDamage.pixman(), TRANSFORM, (int)pMonitor->vecTransformedSize.x, (int)pMonitor->vecTransformedSize.y);
+        frameDamage.transform(wlTransformToHyprutils(TRANSFORM), pMonitor->vecTransformedSize.x, pMonitor->vecTransformedSize.y);
 
         if (*PDAMAGETRACKINGMODE == DAMAGE_TRACKING_NONE || *PDAMAGETRACKINGMODE == DAMAGE_TRACKING_MONITOR)
             frameDamage.add(0, 0, (int)pMonitor->vecTransformedSize.x, (int)pMonitor->vecTransformedSize.y);
@@ -1824,7 +1825,7 @@ void CHyprRenderer::damageMirrorsWith(CMonitor* pMonitor, const CRegion& pRegion
         monbox.x      = (monitor->vecTransformedSize.x - monbox.w) / 2;
         monbox.y      = (monitor->vecTransformedSize.y - monbox.h) / 2;
 
-        wlr_region_scale(transformed.pixman(), transformed.pixman(), scale);
+        transformed.scale(scale);
         transformed.transform(wlTransformToHyprutils(mirrored->transform), mirrored->vecPixelSize.x * scale, mirrored->vecPixelSize.y * scale);
         transformed.translate(Vector2D(monbox.x, monbox.y));
 
@@ -2231,7 +2232,7 @@ bool CHyprRenderer::applyMonitorRule(CMonitor* pMonitor, SMonitorRule* pMonitorR
 
     if (pMonitor->createdByUser) {
         CBox transformedBox = {0, 0, pMonitor->vecTransformedSize.x, pMonitor->vecTransformedSize.y};
-        transformedBox.transform(wlTransformToHyprutils(wlr_output_transform_invert(pMonitor->transform)), pMonitor->vecTransformedSize.x, pMonitor->vecTransformedSize.y);
+        transformedBox.transform(wlTransformToHyprutils(invertTransform(pMonitor->transform)), pMonitor->vecTransformedSize.x, pMonitor->vecTransformedSize.y);
 
         pMonitor->vecPixelSize = Vector2D(transformedBox.width, transformedBox.height);
     }

src/render/Texture.cpp

@@ -20,23 +20,6 @@ CTexture::CTexture(uint32_t drmFormat, uint8_t* pixels, uint32_t stride, const V
     createFromShm(drmFormat, pixels, stride, size_);
 }
 
-CTexture::CTexture(wlr_texture* tex) {
-    RASSERT(wlr_texture_is_gles2(tex), "wlr_texture provided to CTexture that isn't GLES2!");
-    wlr_gles2_texture_attribs attrs;
-    wlr_gles2_texture_get_attribs(tex, &attrs);
-
-    m_iTarget    = attrs.target;
-    m_iTexID     = attrs.tex;
-    m_bNonOwning = true;
-
-    if (m_iTarget == GL_TEXTURE_2D)
-        m_iType = attrs.has_alpha ? TEXTURE_RGBA : TEXTURE_RGBX;
-    else
-        m_iType = TEXTURE_EXTERNAL;
-
-    m_vSize = Vector2D((int)tex->width, (int)tex->height);
-}
-
 CTexture::CTexture(const Aquamarine::SDMABUFAttrs& attrs, void* image) {
     createFromDma(attrs, image);
 }

src/render/Texture.hpp

@@ -23,7 +23,6 @@ class CTexture {
     CTexture(const CTexture&)  = delete;
 
     CTexture(uint32_t drmFormat, uint8_t* pixels, uint32_t stride, const Vector2D& size);
-    CTexture(wlr_texture*);
 
     CTexture(const SP<Aquamarine::IBuffer> buffer);
     // this ctor takes ownership of the eglImage.

src/signal-safe.hpp

@@ -1,6 +1,7 @@
 #pragma once
 
 #include "defines.hpp"
+#include <cstring>
 
 template <uint16_t N>
 class MaxLengthCString {

src/xwayland/Server.cpp

@@ -23,7 +23,7 @@
 static bool set_cloexec(int fd, bool cloexec) {
     int flags = fcntl(fd, F_GETFD);
     if (flags == -1) {
-        wlr_log_errno(WLR_ERROR, "fcntl failed");
+        Debug::log(ERR, "fcntl failed");
         return false;
     }
     if (cloexec) {
@@ -32,7 +32,7 @@ static bool set_cloexec(int fd, bool cloexec) {
         flags = flags & ~FD_CLOEXEC;
     }
     if (fcntl(fd, F_SETFD, flags) == -1) {
-        wlr_log_errno(WLR_ERROR, "fcntl failed");
+        Debug::log(ERR, "fcntl failed");
         return false;
     }
     return true;
@@ -44,7 +44,7 @@ static int openSocket(struct sockaddr_un* addr, size_t path_size) {
 
     fd = socket(AF_UNIX, SOCK_STREAM, 0);
     if (fd < 0) {
-        wlr_log_errno(WLR_ERROR, "Failed to create socket %c%s", addr->sun_path[0] ? addr->sun_path[0] : '@', addr->sun_path + 1);
+        Debug::log(ERR, "failed to create socket {}{}", addr->sun_path[0] ? addr->sun_path[0] : '@', addr->sun_path + 1);
         return -1;
     }
     if (!set_cloexec(fd, true)) {
@@ -57,12 +57,12 @@ static int openSocket(struct sockaddr_un* addr, size_t path_size) {
     }
     if (bind(fd, (struct sockaddr*)addr, size) < 0) {
         rc = errno;
-        wlr_log_errno(WLR_ERROR, "Failed to bind socket %c%s", addr->sun_path[0] ? addr->sun_path[0] : '@', addr->sun_path + 1);
+        Debug::log(ERR, "failed to bind socket {}{}", addr->sun_path[0] ? addr->sun_path[0] : '@', addr->sun_path + 1);
         goto cleanup;
     }
     if (listen(fd, 1) < 0) {
         rc = errno;
-        wlr_log_errno(WLR_ERROR, "Failed to listen to socket %c%s", addr->sun_path[0] ? addr->sun_path[0] : '@', addr->sun_path + 1);
+        Debug::log(ERR, "failed to listen to socket {}{}", addr->sun_path[0] ? addr->sun_path[0] : '@', addr->sun_path + 1);
         goto cleanup;
     }
 

src/xwayland/XWM.cpp

@@ -753,7 +753,7 @@ void CXWM::getVisual() {
     }
 
     if (visualtype == NULL) {
-        wlr_log(WLR_DEBUG, "No 32 bit visualtype\n");
+        Debug::log(LOG, "xwm: No 32-bit visualtype");
         return;
     }
 
@@ -766,7 +766,7 @@ void CXWM::getRenderFormat() {
     xcb_render_query_pict_formats_cookie_t cookie = xcb_render_query_pict_formats(connection);
     xcb_render_query_pict_formats_reply_t* reply  = xcb_render_query_pict_formats_reply(connection, cookie, NULL);
     if (!reply) {
-        wlr_log(WLR_ERROR, "Did not get any reply from xcb_render_query_pict_formats");
+        Debug::log(LOG, "xwm: No xcb_render_query_pict_formats_reply_t reply");
         return;
     }
     xcb_render_pictforminfo_iterator_t iter   = xcb_render_query_pict_formats_formats_iterator(reply);
@@ -781,7 +781,7 @@ void CXWM::getRenderFormat() {
     }
 
     if (format == NULL) {
-        wlr_log(WLR_DEBUG, "No 32 bit render format");
+        Debug::log(LOG, "xwm: No 32-bit render format");
         free(reply);
         return;
     }

subprojects/wlroots-hyprland

@@ -1 +0,0 @@
-Subproject commit 422207dbcf0949e28042403edab539159282885e