misc: use Vector2D, Box and Mat3x3 from hyprutils (#515)

* misc: use Vector2D, Box and Mat3x3 from hyprutils

* nix: flake update

Fix CI fails. We need hyprutils>=0.2.3

* misc: use a function to convert Hyprlang::VEC2 to Vector2D

* misc: fixup some includes

CMakeLists.txt

@@ -56,7 +56,7 @@ pkg_check_modules(
   pangocairo
   libdrm
   gbm
-  hyprutils>=0.2.0)
+  hyprutils>=0.2.3)
 
 file(GLOB_RECURSE SRCFILES CONFIGURE_DEPENDS "src/*.cpp")
 add_executable(hyprlock ${SRCFILES})

flake.lock

@@ -13,11 +13,11 @@
         ]
       },
       "locked": {
-        "lastModified": 1721324361,
+        "lastModified": 1728168612,
-        "narHash": "sha256-BiJKO0IIdnSwHQBSrEJlKlFr753urkLE48wtt0UhNG4=",
+        "narHash": "sha256-AnB1KfiXINmuiW7BALYrKqcjCnsLZPifhb/7BsfPbns=",
         "owner": "hyprwm",
         "repo": "hyprlang",
-        "rev": "adbefbf49664a6c2c8bf36b6487fd31e3eb68086",
+        "rev": "f054f2e44d6a0b74607a6bc0f52dba337a3db38e",
         "type": "github"
       },
       "original": {
@@ -36,11 +36,11 @@
         ]
       },
       "locked": {
-        "lastModified": 1721324102,
+        "lastModified": 1727300645,
-        "narHash": "sha256-WAZ0X6yJW1hFG6otkHBfyJDKRpNP5stsRqdEuHrFRpk=",
+        "narHash": "sha256-OvAtVLaSRPnbXzOwlR1fVqCXR7i+ICRX3aPMCdIiv+c=",
         "owner": "hyprwm",
         "repo": "hyprutils",
-        "rev": "962582a090bc233c4de9d9897f46794280288989",
+        "rev": "3f5293432b6dc6a99f26aca2eba3876d2660665c",
         "type": "github"
       },
       "original": {
@@ -51,11 +51,11 @@
     },
     "nixpkgs": {
       "locked": {
-        "lastModified": 1721138476,
+        "lastModified": 1728492678,
-        "narHash": "sha256-+W5eZOhhemLQxelojLxETfbFbc19NWawsXBlapYpqIA=",
+        "narHash": "sha256-9UTxR8eukdg+XZeHgxW5hQA9fIKHsKCdOIUycTryeVw=",
         "owner": "NixOS",
         "repo": "nixpkgs",
-        "rev": "ad0b5eed1b6031efaed382844806550c3dcb4206",
+        "rev": "5633bcff0c6162b9e4b5f1264264611e950c8ec7",
         "type": "github"
       },
       "original": {

src/config/ConfigManager.cpp

@@ -1,6 +1,6 @@
 #include "ConfigManager.hpp"
 #include "../helpers/MiscFunctions.hpp"
-#include "src/helpers/Log.hpp"
+#include "../helpers/Log.hpp"
 #include <hyprutils/path/Path.hpp>
 #include <filesystem>
 #include <glob.h>

src/core/LockSurface.cpp

@@ -7,7 +7,7 @@
 
 static void handleConfigure(void* data, ext_session_lock_surface_v1* surf, uint32_t serial, uint32_t width, uint32_t height) {
     const auto PSURF = (CSessionLockSurface*)data;
-    PSURF->configure({width, height}, serial);
+    PSURF->configure({(double)width, (double)height}, serial);
 }
 
 static const ext_session_lock_surface_v1_listener lockListener = {

src/core/LockSurface.hpp

@@ -4,8 +4,8 @@
 #include "ext-session-lock-v1-protocol.h"
 #include "viewporter-protocol.h"
 #include "fractional-scale-v1-protocol.h"
+#include "../helpers/Math.hpp"
 #include <wayland-egl.h>
-#include "../helpers/Vector2D.hpp"
 #include <EGL/egl.h>
 
 class COutput;

src/core/Output.hpp

@@ -1,7 +1,7 @@
 #pragma once
 
 #include <wayland-client.h>
-#include "../helpers/Vector2D.hpp"
+#include "../helpers/Math.hpp"
 #include "LockSurface.hpp"
 #include <memory>
 

src/helpers/Box.cpp

@@ -1,101 +0,0 @@
-#include "Box.hpp"
-#include <cmath>
-#include <limits>
-#include <algorithm>
-
-#define VECINRECT(vec, x1, y1, x2, y2) ((vec).x >= (x1) && (vec).x <= (x2) && (vec).y >= (y1) && (vec).y <= (y2))
-
-CBox& CBox::scale(double scale) {
-    x *= scale;
-    y *= scale;
-    w *= scale;
-    h *= scale;
-
-    return *this;
-}
-
-CBox& CBox::scale(const Vector2D& scale) {
-    x *= scale.x;
-    y *= scale.y;
-    w *= scale.x;
-    h *= scale.y;
-
-    return *this;
-}
-
-CBox& CBox::translate(const Vector2D& vec) {
-    x += vec.x;
-    y += vec.y;
-
-    return *this;
-}
-
-Vector2D CBox::middle() const {
-    return Vector2D{x + w / 2.0, y + h / 2.0};
-}
-
-bool CBox::containsPoint(const Vector2D& vec) const {
-    return VECINRECT(vec, x, y, x + w, y + h);
-}
-
-bool CBox::empty() const {
-    return w == 0 || h == 0;
-}
-
-CBox& CBox::round() {
-    float newW = x + w - std::round(x);
-    float newH = y + h - std::round(y);
-    x          = std::round(x);
-    y          = std::round(y);
-    w          = std::round(newW);
-    h          = std::round(newH);
-
-    return *this;
-}
-
-CBox& CBox::scaleFromCenter(double scale) {
-    double oldW = w, oldH = h;
-
-    w *= scale;
-    h *= scale;
-
-    x -= (w - oldW) / 2.0;
-    y -= (h - oldH) / 2.0;
-
-    return *this;
-}
-
-CBox& CBox::expand(const double& value) {
-    x -= value;
-    y -= value;
-    w += value * 2.0;
-    h += value * 2.0;
-
-    return *this;
-}
-
-CBox& CBox::noNegativeSize() {
-    std::clamp(w, 0.0, std::numeric_limits<double>::infinity());
-    std::clamp(h, 0.0, std::numeric_limits<double>::infinity());
-
-    return *this;
-}
-
-CBox CBox::roundInternal() {
-    float newW = x + w - std::floor(x);
-    float newH = y + h - std::floor(y);
-
-    return CBox{std::floor(x), std::floor(y), std::floor(newW), std::floor(newH)};
-}
-
-CBox CBox::copy() const {
-    return CBox{*this};
-}
-
-Vector2D CBox::pos() const {
-    return {x, y};
-}
-
-Vector2D CBox::size() const {
-    return {w, h};
-}

src/helpers/Box.hpp

@@ -1,68 +0,0 @@
-#pragma once
-#include "Vector2D.hpp"
-
-class CBox {
-  public:
-    CBox(double x_, double y_, double w_, double h_) {
-        x = x_;
-        y = y_;
-        w = w_;
-        h = h_;
-    }
-
-    CBox() {
-        w = 0;
-        h = 0;
-    }
-
-    CBox(const double d) {
-        x = d;
-        y = d;
-        w = d;
-        h = d;
-    }
-
-    CBox(const Vector2D& pos, const Vector2D& size) {
-        x = pos.x;
-        y = pos.y;
-        w = size.x;
-        h = size.y;
-    }
-
-    CBox&    scale(double scale);
-    CBox&    scaleFromCenter(double scale);
-    CBox&    scale(const Vector2D& scale);
-    CBox&    translate(const Vector2D& vec);
-    CBox&    round();
-    CBox&    expand(const double& value);
-    CBox&    noNegativeSize();
-
-    CBox     copy() const;
-
-    Vector2D middle() const;
-    Vector2D pos() const;
-    Vector2D size() const;
-
-    bool     containsPoint(const Vector2D& vec) const;
-    bool     empty() const;
-
-    double   x = 0, y = 0;
-    union {
-        double w;
-        double width;
-    };
-    union {
-        double h;
-        double height;
-    };
-
-    double rot = 0; /* rad, ccw */
-
-    //
-    bool operator==(const CBox& rhs) const {
-        return x == rhs.x && y == rhs.y && w == rhs.w && h == rhs.h;
-    }
-
-  private:
-    CBox roundInternal();
-};

src/helpers/Math.cpp

@@ -0,0 +1,23 @@
+#include "Math.hpp"
+
+Hyprutils::Math::eTransform wlTransformToHyprutils(wl_output_transform t) {
+    switch (t) {
+        case WL_OUTPUT_TRANSFORM_NORMAL: return Hyprutils::Math::eTransform::HYPRUTILS_TRANSFORM_NORMAL;
+        case WL_OUTPUT_TRANSFORM_180: return Hyprutils::Math::eTransform::HYPRUTILS_TRANSFORM_180;
+        case WL_OUTPUT_TRANSFORM_90: return Hyprutils::Math::eTransform::HYPRUTILS_TRANSFORM_90;
+        case WL_OUTPUT_TRANSFORM_270: return Hyprutils::Math::eTransform::HYPRUTILS_TRANSFORM_270;
+        case WL_OUTPUT_TRANSFORM_FLIPPED: return Hyprutils::Math::eTransform::HYPRUTILS_TRANSFORM_FLIPPED;
+        case WL_OUTPUT_TRANSFORM_FLIPPED_180: return Hyprutils::Math::eTransform::HYPRUTILS_TRANSFORM_FLIPPED_180;
+        case WL_OUTPUT_TRANSFORM_FLIPPED_270: return Hyprutils::Math::eTransform::HYPRUTILS_TRANSFORM_FLIPPED_270;
+        case WL_OUTPUT_TRANSFORM_FLIPPED_90: return Hyprutils::Math::eTransform::HYPRUTILS_TRANSFORM_FLIPPED_90;
+        default: break;
+    }
+    return Hyprutils::Math::eTransform::HYPRUTILS_TRANSFORM_NORMAL;
+}
+
+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.hpp

@@ -0,0 +1,12 @@
+#pragma once
+
+#include <wayland-client.h>
+
+#include <hyprutils/math/Box.hpp>
+#include <hyprutils/math/Vector2D.hpp>
+#include <hyprutils/math/Mat3x3.hpp>
+
+using namespace Hyprutils::Math;
+
+eTransform          wlTransformToHyprutils(wl_output_transform t);
+wl_output_transform invertTransform(wl_output_transform tr);

src/helpers/MiscFunctions.hpp

@@ -1,5 +1,12 @@
 #pragma once
 
 #include <string>
+#include <hyprlang.hpp>
+#include <hyprutils/math/Vector2D.hpp>
 
 std::string absolutePath(const std::string&, const std::string&);
+
+//
+inline Hyprutils::Math::Vector2D Vector2DFromHyprlang(const Hyprlang::VEC2& vec) {
+    return Hyprutils::Math::Vector2D{vec.x, vec.y};
+};

src/helpers/Vector2D.cpp

@@ -1,57 +0,0 @@
-#include "Vector2D.hpp"
-#include <algorithm>
-#include <cmath>
-
-Vector2D::Vector2D(double xx, double yy) {
-    x = xx;
-    y = yy;
-}
-
-Vector2D::Vector2D() {
-    x = 0;
-    y = 0;
-}
-
-Vector2D::~Vector2D() {}
-
-double Vector2D::normalize() {
-    // get max abs
-    const auto max = std::abs(x) > std::abs(y) ? std::abs(x) : std::abs(y);
-
-    x /= max;
-    y /= max;
-
-    return max;
-}
-
-Vector2D Vector2D::floor() const {
-    return Vector2D(std::floor(x), std::floor(y));
-}
-
-Vector2D Vector2D::round() const {
-    return Vector2D(std::round(x), std::round(y));
-}
-
-Vector2D Vector2D::clamp(const Vector2D& min, const Vector2D& max) const {
-    return Vector2D(std::clamp(this->x, min.x, max.x < min.x ? INFINITY : max.x), std::clamp(this->y, min.y, max.y < min.y ? INFINITY : max.y));
-}
-
-double Vector2D::distance(const Vector2D& other) const {
-    double dx = x - other.x;
-    double dy = y - other.y;
-    return std::sqrt(dx * dx + dy * dy);
-}
-
-double Vector2D::size() const {
-    return std::sqrt(x * x + y * y);
-}
-
-Vector2D Vector2D::getComponentMax(const Vector2D& other) const {
-    return Vector2D(std::max(this->x, other.x), std::max(this->y, other.y));
-}
-
-Vector2D Vector2D::rotated(const double& ang) const {
-    const double COS = std::abs(std::cos(ang));
-    const double SIN = std::abs(std::sin(ang));
-    return Vector2D(x * COS + y * SIN, x * SIN + y * COS);
-}

src/helpers/Vector2D.hpp

@@ -1,159 +0,0 @@
-#pragma once
-
-#include <format>
-#include <hyprlang.hpp>
-
-class Vector2D {
-  public:
-    Vector2D(double, double);
-    Vector2D();
-    Vector2D(const Hyprlang::VEC2& v) {
-        x = v.x;
-        y = v.y;
-    }
-    ~Vector2D();
-
-    double x = 0;
-    double y = 0;
-
-    // returns the scale
-    double   normalize();
-
-    Vector2D operator+(const Vector2D& a) const {
-        return Vector2D(this->x + a.x, this->y + a.y);
-    }
-    Vector2D operator-(const Vector2D& a) const {
-        return Vector2D(this->x - a.x, this->y - a.y);
-    }
-    Vector2D operator-() const {
-        return Vector2D(-this->x, -this->y);
-    }
-    Vector2D operator*(const double& a) const {
-        return Vector2D(this->x * a, this->y * a);
-    }
-    Vector2D operator/(const double& a) const {
-        return Vector2D(this->x / a, this->y / a);
-    }
-
-    bool operator==(const Vector2D& a) const {
-        return a.x == x && a.y == y;
-    }
-
-    bool operator!=(const Vector2D& a) const {
-        return a.x != x || a.y != y;
-    }
-
-    Vector2D operator*(const Vector2D& a) const {
-        return Vector2D(this->x * a.x, this->y * a.y);
-    }
-
-    Vector2D operator/(const Vector2D& a) const {
-        return Vector2D(this->x / a.x, this->y / a.y);
-    }
-
-    bool operator>(const Vector2D& a) const {
-        return this->x > a.x && this->y > a.y;
-    }
-
-    bool operator<(const Vector2D& a) const {
-        return this->x < a.x && this->y < a.y;
-    }
-    Vector2D& operator+=(const Vector2D& a) {
-        this->x += a.x;
-        this->y += a.y;
-        return *this;
-    }
-    Vector2D& operator-=(const Vector2D& a) {
-        this->x -= a.x;
-        this->y -= a.y;
-        return *this;
-    }
-    Vector2D& operator*=(const Vector2D& a) {
-        this->x *= a.x;
-        this->y *= a.y;
-        return *this;
-    }
-    Vector2D& operator/=(const Vector2D& a) {
-        this->x /= a.x;
-        this->y /= a.y;
-        return *this;
-    }
-    Vector2D& operator*=(const double& a) {
-        this->x *= a;
-        this->y *= a;
-        return *this;
-    }
-    Vector2D& operator/=(const double& a) {
-        this->x /= a;
-        this->y /= a;
-        return *this;
-    }
-
-    double   distance(const Vector2D& other) const;
-    double   size() const;
-    Vector2D clamp(const Vector2D& min, const Vector2D& max = Vector2D{-1, -1}) const;
-
-    Vector2D floor() const;
-    Vector2D round() const;
-
-    Vector2D getComponentMax(const Vector2D& other) const;
-    Vector2D rotated(const double& ang) const;
-};
-
-/**
-    format specification
-    - 'j', as json array
-    - 'X', same as std::format("{}x{}", vec.x, vec.y)
-    - number, floating point precision, use `0` to format as integer
-*/
-// absolutely ridiculous formatter spec parsing
-#define FORMAT_PARSE(specs__, type__)                                                                                                                                              \
-    template <typename FormatContext>                                                                                                                                              \
-    constexpr auto parse(FormatContext& ctx) {                                                                                                                                     \
-        auto it = ctx.begin();                                                                                                                                                     \
-        for (; it != ctx.end() && *it != '}'; it++) {                                                                                                                              \
-            switch (*it) { specs__ default : throw std::format_error("invalid format specification"); }                                                                            \
-        }                                                                                                                                                                          \
-        return it;                                                                                                                                                                 \
-    }
-
-#define FORMAT_FLAG(spec__, flag__)                                                                                                                                                \
-    case spec__: (flag__) = true; break;
-
-#define FORMAT_NUMBER(buf__)                                                                                                                                                       \
-    case '0':                                                                                                                                                                      \
-    case '1':                                                                                                                                                                      \
-    case '2':                                                                                                                                                                      \
-    case '3':                                                                                                                                                                      \
-    case '4':                                                                                                                                                                      \
-    case '5':                                                                                                                                                                      \
-    case '6':                                                                                                                                                                      \
-    case '7':                                                                                                                                                                      \
-    case '8':                                                                                                                                                                      \
-    case '9': (buf__).push_back(*it); break;
-template <typename CharT>
-struct std::formatter<Vector2D, CharT> : std::formatter<CharT> {
-    bool        formatJson = false;
-    bool        formatX    = false;
-    std::string precision  = "";
-    FORMAT_PARSE(FORMAT_FLAG('j', formatJson) //
-                 FORMAT_FLAG('X', formatX)    //
-                 FORMAT_NUMBER(precision),
-                 Vector2D)
-
-    template <typename FormatContext>
-    auto format(const Vector2D& vec, FormatContext& ctx) const {
-        std::string formatString = precision.empty() ? "{}" : std::format("{{:.{}f}}", precision);
-
-        if (formatJson)
-            formatString = std::format("[{0}, {0}]", formatString);
-        else if (formatX)
-            formatString = std::format("{0}x{0}", formatString);
-        else
-            formatString = std::format("[Vector2D: x: {0}, y: {0}]", formatString);
-        try {
-            string buf = std::vformat(formatString, std::make_format_args(vec.x, vec.y));
-            return std::format_to(ctx.out(), "{}", buf);
-        } catch (std::format_error& e) { return std::format_to(ctx.out(), "[{}, {}]", vec.x, vec.y); }
-    }
-};

src/renderer/Framebuffer.hpp

@@ -1,6 +1,6 @@
 #pragma once
 
-#include "../helpers/Vector2D.hpp"
+#include "../helpers/Math.hpp"
 #include <GLES3/gl32.h>
 #include "Texture.hpp"
 

src/renderer/Renderer.cpp

@@ -5,7 +5,6 @@
 #include "../core/Output.hpp"
 #include "../core/hyprlock.hpp"
 #include "../renderer/DMAFrame.hpp"
-#include "mtx.hpp"
 #include <GLES3/gl32.h>
 #include <GLES3/gl3ext.h>
 #include <algorithm>
@@ -151,8 +150,6 @@ CRenderer::CRenderer() {
     blurFinishShader.colorizeTint = glGetUniformLocation(prog, "colorizeTint");
     blurFinishShader.boostA       = glGetUniformLocation(prog, "boostA");
 
-    wlr_matrix_identity(projMatrix.data());
-
     asyncResourceGatherer = std::make_unique<CAsyncResourceGatherer>();
 }
 
@@ -164,7 +161,7 @@ CRenderer::SRenderFeedback CRenderer::renderLock(const CSessionLockSurface& surf
     static auto* const PDISABLEBAR = (Hyprlang::INT* const*)g_pConfigManager->getValuePtr("general:disable_loading_bar");
     static auto* const PNOFADEOUT  = (Hyprlang::INT* const*)g_pConfigManager->getValuePtr("general:no_fade_out");
 
-    matrixProjection(projection.data(), surf.size.x, surf.size.y, WL_OUTPUT_TRANSFORM_NORMAL);
+    projection = Mat3x3::outputProjection(surf.size, HYPRUTILS_TRANSFORM_NORMAL);
 
     g_pEGL->makeCurrent(surf.eglSurface);
     glViewport(0, 0, surf.size.x, surf.size.y);
@@ -226,16 +223,12 @@ CRenderer::SRenderFeedback CRenderer::renderLock(const CSessionLockSurface& surf
 }
 
 void CRenderer::renderRect(const CBox& box, const CColor& col, int rounding) {
-    float matrix[9];
+    Mat3x3 matrix   = projMatrix.projectBox(box, HYPRUTILS_TRANSFORM_NORMAL, box.rot);
-    wlr_matrix_project_box(matrix, &box, WL_OUTPUT_TRANSFORM_NORMAL, box.rot,
+    Mat3x3 glMatrix = projection.copy().multiply(matrix);
-                           projMatrix.data()); // TODO: write own, don't use WLR here
-
-    float glMatrix[9];
-    wlr_matrix_multiply(glMatrix, projection.data(), matrix);
 
     glUseProgram(rectShader.program);
 
-    glUniformMatrix3fv(rectShader.proj, 1, GL_TRUE, glMatrix);
+    glUniformMatrix3fv(rectShader.proj, 1, GL_TRUE, glMatrix.getMatrix().data());
 
     // premultiply the color as well as we don't work with straight alpha
     glUniform4f(rectShader.color, col.r * col.a, col.g * col.a, col.b * col.a, col.a);
@@ -257,13 +250,9 @@ void CRenderer::renderRect(const CBox& box, const CColor& col, int rounding) {
     glDisableVertexAttribArray(rectShader.posAttrib);
 }
 
-void CRenderer::renderTexture(const CBox& box, const CTexture& tex, float a, int rounding, std::optional<wl_output_transform> tr) {
+void CRenderer::renderTexture(const CBox& box, const CTexture& tex, float a, int rounding, std::optional<eTransform> tr) {
-    float matrix[9];
+    Mat3x3   matrix   = projMatrix.projectBox(box, tr.value_or(HYPRUTILS_TRANSFORM_FLIPPED_180), box.rot);
-    wlr_matrix_project_box(matrix, &box, tr.value_or(WL_OUTPUT_TRANSFORM_FLIPPED_180) /* ugh coordinate spaces */, box.rot,
+    Mat3x3   glMatrix = projection.copy().multiply(matrix);
-                           projMatrix.data()); // TODO: write own, don't use WLR here
-
-    float glMatrix[9];
-    wlr_matrix_multiply(glMatrix, projection.data(), matrix);
 
     CShader* shader = &texShader;
 
@@ -272,7 +261,7 @@ void CRenderer::renderTexture(const CBox& box, const CTexture& tex, float a, int
 
     glUseProgram(shader->program);
 
-    glUniformMatrix3fv(shader->proj, 1, GL_TRUE, glMatrix);
+    glUniformMatrix3fv(shader->proj, 1, GL_TRUE, glMatrix.getMatrix().data());
     glUniform1i(shader->tex, 0);
     glUniform1f(shader->alpha, a);
     const auto TOPLEFT  = Vector2D(box.x, box.y);
@@ -363,13 +352,9 @@ void CRenderer::blurFB(const CFramebuffer& outfb, SBlurParams params) {
     glDisable(GL_BLEND);
     glDisable(GL_STENCIL_TEST);
 
-    float matrix[9];
     CBox         box{0, 0, outfb.m_vSize.x, outfb.m_vSize.y};
-    wlr_matrix_project_box(matrix, &box, WL_OUTPUT_TRANSFORM_NORMAL, 0,
+    Mat3x3       matrix   = projMatrix.projectBox(box, HYPRUTILS_TRANSFORM_NORMAL, 0);
-                           projMatrix.data()); // TODO: write own, don't use WLR here
+    Mat3x3       glMatrix = projection.copy().multiply(matrix);
-
-    float glMatrix[9];
-    wlr_matrix_multiply(glMatrix, projection.data(), matrix);
 
     CFramebuffer mirrors[2];
     mirrors[0].alloc(outfb.m_vSize.x, outfb.m_vSize.y, true);
@@ -390,7 +375,7 @@ void CRenderer::blurFB(const CFramebuffer& outfb, SBlurParams params) {
 
         glUseProgram(blurPrepareShader.program);
 
-        glUniformMatrix3fv(blurPrepareShader.proj, 1, GL_TRUE, glMatrix);
+        glUniformMatrix3fv(blurPrepareShader.proj, 1, GL_TRUE, glMatrix.getMatrix().data());
         glUniform1f(blurPrepareShader.contrast, params.contrast);
         glUniform1f(blurPrepareShader.brightness, params.brightness);
         glUniform1i(blurPrepareShader.tex, 0);
@@ -425,7 +410,7 @@ void CRenderer::blurFB(const CFramebuffer& outfb, SBlurParams params) {
         glUseProgram(pShader->program);
 
         // prep two shaders
-        glUniformMatrix3fv(pShader->proj, 1, GL_TRUE, glMatrix);
+        glUniformMatrix3fv(pShader->proj, 1, GL_TRUE, glMatrix.getMatrix().data());
         glUniform1f(pShader->radius, params.size);
         if (pShader == &blurShader1) {
             glUniform2f(blurShader1.halfpixel, 0.5f / (outfb.m_vSize.x / 2.f), 0.5f / (outfb.m_vSize.y / 2.f));
@@ -481,7 +466,7 @@ void CRenderer::blurFB(const CFramebuffer& outfb, SBlurParams params) {
 
         glUseProgram(blurFinishShader.program);
 
-        glUniformMatrix3fv(blurFinishShader.proj, 1, GL_TRUE, glMatrix);
+        glUniformMatrix3fv(blurFinishShader.proj, 1, GL_TRUE, glMatrix.getMatrix().data());
         glUniform1f(blurFinishShader.noise, params.noise);
         glUniform1f(blurFinishShader.brightness, params.brightness);
         glUniform1i(blurFinishShader.colorize, params.colorize.has_value());
@@ -510,7 +495,7 @@ void CRenderer::blurFB(const CFramebuffer& outfb, SBlurParams params) {
 
     // finish
     outfb.bind();
-    renderTexture(box, currentRenderToFB->m_cTex, 1.0, 0, WL_OUTPUT_TRANSFORM_NORMAL);
+    renderTexture(box, currentRenderToFB->m_cTex, 1.0, 0, HYPRUTILS_TRANSFORM_NORMAL);
 
     glEnable(GL_BLEND);
 }

src/renderer/Renderer.hpp

@@ -3,10 +3,10 @@
 #include <memory>
 #include <chrono>
 #include <optional>
-#include "../core/LockSurface.hpp"
 #include "Shader.hpp"
-#include "../helpers/Box.hpp"
+#include "../core/LockSurface.hpp"
 #include "../helpers/Color.hpp"
+#include "../helpers/Math.hpp"
 #include "AsyncResourceGatherer.hpp"
 #include "widgets/IWidget.hpp"
 #include "Framebuffer.hpp"
@@ -31,7 +31,7 @@ class CRenderer {
     SRenderFeedback                         renderLock(const CSessionLockSurface& surface);
 
     void                                    renderRect(const CBox& box, const CColor& col, int rounding = 0);
-    void                                    renderTexture(const CBox& box, const CTexture& tex, float a = 1.0, int rounding = 0, std::optional<wl_output_transform> tr = {});
+    void                                    renderTexture(const CBox& box, const CTexture& tex, float a = 1.0, int rounding = 0, std::optional<eTransform> tr = {});
     void                                    blurFB(const CFramebuffer& outfb, SBlurParams params);
 
     std::unique_ptr<CAsyncResourceGatherer> asyncResourceGatherer;
@@ -54,8 +54,8 @@ class CRenderer {
     CShader                                blurPrepareShader;
     CShader                                blurFinishShader;
 
-    std::array<float, 9>                   projMatrix;
+    Mat3x3                                 projMatrix = Mat3x3::identity();
-    std::array<float, 9>                   projection;
+    Mat3x3                                 projection;
 
     std::vector<GLint>                     boundFBs;
 };

src/renderer/Texture.hpp

@@ -1,7 +1,7 @@
 #pragma once
 
 #include <GLES3/gl32.h>
-#include "../helpers/Vector2D.hpp"
+#include "../helpers/Math.hpp"
 
 enum TEXTURETYPE {
     TEXTURE_INVALID,  // Invalid

src/renderer/widgets/Background.cpp

@@ -1,6 +1,6 @@
 #include "Background.hpp"
 #include "../Renderer.hpp"
-#include "../mtx.hpp"
+#include <hyprlang.hpp>
 
 CBackground::CBackground(const Vector2D& viewport_, COutput* output_, const std::string& resourceID_, const std::unordered_map<std::string, std::any>& props, bool ss) :
     viewport(viewport_), resourceID(resourceID_), output(output_), isScreenshot(ss) {
@@ -72,8 +72,8 @@ bool CBackground::draw(const SRenderData& data) {
 
         g_pRenderer->renderTexture(texbox, asset->texture, 1.0, 0,
                                    isScreenshot ?
-                                       wlr_output_transform_invert(output->transform) :
+                                       wlTransformToHyprutils(invertTransform(output->transform)) :
-                                       WL_OUTPUT_TRANSFORM_NORMAL); // this could be omitted but whatever it's only once and makes code cleaner plus less blurring on large texs
+                                       HYPRUTILS_TRANSFORM_NORMAL); // this could be omitted but whatever it's only once and makes code cleaner plus less blurring on large texs
         if (blurPasses > 0)
             g_pRenderer->blurFB(blurredFB, CRenderer::SBlurParams{blurSize, blurPasses, noise, contrast, brightness, vibrancy, vibrancy_darkness});
         glBindFramebuffer(GL_DRAW_FRAMEBUFFER, 0);
@@ -95,7 +95,7 @@ bool CBackground::draw(const SRenderData& data) {
     else
         texbox.x = -(texbox.w - viewport.x) / 2.f;
     texbox.round();
-    g_pRenderer->renderTexture(texbox, *tex, data.opacity, 0, WL_OUTPUT_TRANSFORM_FLIPPED_180);
+    g_pRenderer->renderTexture(texbox, *tex, data.opacity, 0, HYPRUTILS_TRANSFORM_FLIPPED_180);
 
     return data.opacity < 1.0;
 }

src/renderer/widgets/Background.hpp

@@ -1,8 +1,8 @@
 #pragma once
 
 #include "IWidget.hpp"
-#include "../../helpers/Vector2D.hpp"
 #include "../../helpers/Color.hpp"
+#include "../../helpers/Math.hpp"
 #include "../Framebuffer.hpp"
 #include <string>
 #include <unordered_map>

src/renderer/widgets/IWidget.cpp

@@ -1,7 +1,7 @@
 #include "IWidget.hpp"
 #include "../../helpers/Log.hpp"
 #include "../../core/hyprlock.hpp"
-#include "src/core/Auth.hpp"
+#include "../../core/Auth.hpp"
 #include <chrono>
 #include <unistd.h>
 #include <pwd.h>
@@ -20,12 +20,18 @@ namespace std {
 }
 #endif
 
+Vector2D rotateVector(const Vector2D& vec, const double& ang) {
+    const double COS = std::abs(std::cos(ang));
+    const double SIN = std::abs(std::sin(ang));
+    return Vector2D(vec.x * COS + vec.y * SIN, vec.x * SIN + vec.y * COS);
+}
+
 Vector2D IWidget::posFromHVAlign(const Vector2D& viewport, const Vector2D& size, const Vector2D& offset, const std::string& halign, const std::string& valign, const double& ang) {
 
     // offset after rotation for alignment
     Vector2D rot;
     if (ang != 0)
-        rot = (size - size.rotated(ang)) / 2.0;
+        rot = (size - rotateVector(size, ang)) / 2.0;
 
     Vector2D pos = offset;
     if (halign == "center")

src/renderer/widgets/IWidget.hpp

@@ -1,6 +1,6 @@
 #pragma once
 
-#include "../../helpers/Vector2D.hpp"
+#include "../../helpers/Math.hpp"
 #include <string>
 
 class IWidget {

src/renderer/widgets/Image.cpp

@@ -2,7 +2,9 @@
 #include "../Renderer.hpp"
 #include "../../core/hyprlock.hpp"
 #include "../../helpers/Log.hpp"
+#include "../../helpers/MiscFunctions.hpp"
 #include <cmath>
+#include <hyprlang.hpp>
 
 CImage::~CImage() {
     if (imageTimer) {
@@ -84,7 +86,7 @@ CImage::CImage(const Vector2D& viewport_, COutput* output_, const std::string& r
     rounding = std::any_cast<Hyprlang::INT>(props.at("rounding"));
     border   = std::any_cast<Hyprlang::INT>(props.at("border_size"));
     color    = std::any_cast<Hyprlang::INT>(props.at("border_color"));
-    pos      = std::any_cast<Hyprlang::VEC2>(props.at("position"));
+    pos      = Vector2DFromHyprlang(std::any_cast<Hyprlang::VEC2>(props.at("position")));
     halign   = std::any_cast<Hyprlang::STRING>(props.at("halign"));
     valign   = std::any_cast<Hyprlang::STRING>(props.at("valign"));
     angle    = std::any_cast<Hyprlang::FLOAT>(props.at("rotate"));
@@ -151,7 +153,7 @@ bool CImage::draw(const SRenderData& data) {
             g_pRenderer->renderRect(borderBox, color, ALLOWROUND ? (rounding == 0 ? 0 : rounding + std::round(border / M_PI)) : std::min(borderBox.w, borderBox.h) / 2.0);
 
         texbox.round();
-        g_pRenderer->renderTexture(texbox, asset->texture, 1.0, ALLOWROUND ? rounding : std::min(texbox.w, texbox.h) / 2.0, WL_OUTPUT_TRANSFORM_NORMAL);
+        g_pRenderer->renderTexture(texbox, asset->texture, 1.0, ALLOWROUND ? rounding : std::min(texbox.w, texbox.h) / 2.0, HYPRUTILS_TRANSFORM_NORMAL);
         g_pRenderer->popFb();
     }
 
@@ -172,7 +174,7 @@ bool CImage::draw(const SRenderData& data) {
 
     texbox.round();
     texbox.rot = angle;
-    g_pRenderer->renderTexture(texbox, *tex, data.opacity, 0, WL_OUTPUT_TRANSFORM_FLIPPED_180);
+    g_pRenderer->renderTexture(texbox, *tex, data.opacity, 0, HYPRUTILS_TRANSFORM_FLIPPED_180);
 
     return data.opacity < 1.0;
 }

src/renderer/widgets/Image.hpp

@@ -1,8 +1,8 @@
 #pragma once
 
 #include "IWidget.hpp"
-#include "../../helpers/Vector2D.hpp"
 #include "../../helpers/Color.hpp"
+#include "../../helpers/Math.hpp"
 #include "../../core/Timer.hpp"
 #include "../AsyncResourceGatherer.hpp"
 #include "Shadowable.hpp"

src/renderer/widgets/Label.cpp

@@ -1,10 +1,11 @@
 #include "Label.hpp"
-#include "../../helpers/Color.hpp"
-#include <hyprlang.hpp>
-#include <stdexcept>
 #include "../Renderer.hpp"
 #include "../../helpers/Log.hpp"
 #include "../../core/hyprlock.hpp"
+#include "../../helpers/Color.hpp"
+#include "../../helpers/MiscFunctions.hpp"
+#include <hyprlang.hpp>
+#include <stdexcept>
 
 CLabel::~CLabel() {
     if (labelTimer) {
@@ -94,8 +95,7 @@ CLabel::CLabel(const Vector2D& viewport_, const std::unordered_map<std::string,
 
         g_pRenderer->asyncResourceGatherer->requestAsyncAssetPreload(request);
 
-        auto POS__ = std::any_cast<Hyprlang::VEC2>(props.at("position"));
+        pos       = Vector2DFromHyprlang(std::any_cast<Hyprlang::VEC2>(props.at("position")));
-        pos        = {POS__.x, POS__.y};
         configPos = pos;
 
         viewport = viewport_;

src/renderer/widgets/Label.hpp

@@ -2,7 +2,7 @@
 
 #include "IWidget.hpp"
 #include "Shadowable.hpp"
-#include "../../helpers/Vector2D.hpp"
+#include "../../helpers/Math.hpp"
 #include "../../core/Timer.hpp"
 #include "../AsyncResourceGatherer.hpp"
 #include <string>

src/renderer/widgets/PasswordInputField.cpp

@@ -2,14 +2,16 @@
 #include "../Renderer.hpp"
 #include "../../core/hyprlock.hpp"
 #include "../../core/Auth.hpp"
+#include "../../helpers/MiscFunctions.hpp"
 #include <hyprutils/string/String.hpp>
 #include <algorithm>
+#include <hyprlang.hpp>
 
 using namespace Hyprutils::String;
 
 CPasswordInputField::CPasswordInputField(const Vector2D& viewport_, const std::unordered_map<std::string, std::any>& props, const std::string& output) :
     outputStringPort(output), shadow(this, props, viewport_) {
-    size                     = std::any_cast<Hyprlang::VEC2>(props.at("size"));
+    size                     = Vector2DFromHyprlang(std::any_cast<Hyprlang::VEC2>(props.at("size")));
     outThick                 = std::any_cast<Hyprlang::INT>(props.at("outline_thickness"));
     dots.size                = std::any_cast<Hyprlang::FLOAT>(props.at("dots_size"));
     dots.spacing             = std::any_cast<Hyprlang::FLOAT>(props.at("dots_spacing"));

src/renderer/widgets/PasswordInputField.hpp

@@ -1,8 +1,8 @@
 #pragma once
 
 #include "IWidget.hpp"
-#include "../../helpers/Vector2D.hpp"
 #include "../../helpers/Color.hpp"
+#include "../../helpers/Math.hpp"
 #include "../../core/Timer.hpp"
 #include "Shadowable.hpp"
 #include <chrono>

src/renderer/widgets/Shadowable.cpp

@@ -1,5 +1,6 @@
 #include "Shadowable.hpp"
 #include "../Renderer.hpp"
+#include <hyprlang.hpp>
 
 CShadowable::CShadowable(IWidget* widget_, const std::unordered_map<std::string, std::any>& props, const Vector2D& viewport_) : widget(widget_), viewport(viewport_) {
     size   = std::any_cast<Hyprlang::INT>(props.at("shadow_size"));
@@ -37,6 +38,6 @@ bool CShadowable::draw(const IWidget::SRenderData& data) {
         return true;
 
     CBox box = {0, 0, viewport.x, viewport.y};
-    g_pRenderer->renderTexture(box, shadowFB.m_cTex, data.opacity, 0, WL_OUTPUT_TRANSFORM_NORMAL);
+    g_pRenderer->renderTexture(box, shadowFB.m_cTex, data.opacity, 0, HYPRUTILS_TRANSFORM_NORMAL);
     return true;
 }

src/renderer/widgets/Shadowable.hpp

@@ -2,6 +2,7 @@
 
 #include "../Framebuffer.hpp"
 #include "../../helpers/Color.hpp"
+#include "../../helpers/Math.hpp"
 #include "IWidget.hpp"
 
 #include <string>

src/renderer/widgets/Shape.cpp

@@ -1,15 +1,17 @@
 #include "Shape.hpp"
 #include "../Renderer.hpp"
+#include "../../helpers/MiscFunctions.hpp"
 #include <cmath>
+#include <hyprlang.hpp>
 
 CShape::CShape(const Vector2D& viewport_, const std::unordered_map<std::string, std::any>& props) : shadow(this, props, viewport_) {
 
-    size        = std::any_cast<Hyprlang::VEC2>(props.at("size"));
+    size        = Vector2DFromHyprlang(std::any_cast<Hyprlang::VEC2>(props.at("size")));
     rounding    = std::any_cast<Hyprlang::INT>(props.at("rounding"));
     border      = std::any_cast<Hyprlang::INT>(props.at("border_size"));
     color       = std::any_cast<Hyprlang::INT>(props.at("color"));
     borderColor = std::any_cast<Hyprlang::INT>(props.at("border_color"));
-    pos         = std::any_cast<Hyprlang::VEC2>(props.at("position"));
+    pos         = Vector2DFromHyprlang(std::any_cast<Hyprlang::VEC2>(props.at("position")));
     halign      = std::any_cast<Hyprlang::STRING>(props.at("halign"));
     valign      = std::any_cast<Hyprlang::STRING>(props.at("valign"));
     angle       = std::any_cast<Hyprlang::FLOAT>(props.at("rotate"));
@@ -83,7 +85,7 @@ bool CShape::draw(const SRenderData& data) {
     texbox.round();
     texbox.rot = angle;
 
-    g_pRenderer->renderTexture(texbox, *tex, data.opacity, 0, WL_OUTPUT_TRANSFORM_FLIPPED_180);
+    g_pRenderer->renderTexture(texbox, *tex, data.opacity, 0, HYPRUTILS_TRANSFORM_FLIPPED_180);
 
     return data.opacity < 1.0;
 }

src/renderer/widgets/Shape.hpp

@@ -1,10 +1,9 @@
 #pragma once
 
 #include "IWidget.hpp"
-#include "../../helpers/Vector2D.hpp"
 #include "../../helpers/Color.hpp"
-#include "../../helpers/Box.hpp"
 #include "Shadowable.hpp"
+#include <hyprutils/math/Box.hpp>
 #include <string>
 #include <unordered_map>
 #include <any>