summaryrefslogtreecommitdiff
path: root/src/render
diff options
context:
space:
mode:
authorUjinT34 <41110182+UjinT34@users.noreply.github.com>2026-03-07 16:13:34 +0300
committerGitHub <noreply@github.com>2026-03-07 13:13:34 +0000
commit966f20d305345b3042dc1d37a1dd8833f3a4783b (patch)
tree3e8515b7a0f6fde7bf3137aac7124ae90e5951ec /src/render
parent32e75e3e320fb66ab517a378df645f3d29b3a209 (diff)
renderer: refactor resources and flags (#13471)
Diffstat (limited to 'src/render')
-rw-r--r--src/render/OpenGL.cpp535
-rw-r--r--src/render/OpenGL.hpp209
-rw-r--r--src/render/Renderbuffer.cpp3
-rw-r--r--src/render/Renderer.cpp411
-rw-r--r--src/render/Renderer.hpp149
-rw-r--r--src/render/decorations/CHyprDropShadowDecoration.cpp8
-rw-r--r--src/render/decorations/CHyprGroupBarDecoration.cpp2
-rw-r--r--src/render/gl/GLFramebuffer.cpp4
-rw-r--r--src/render/gl/GLRenderbuffer.cpp4
-rw-r--r--src/render/gl/GLTexture.cpp6
-rw-r--r--src/render/pass/Pass.cpp16
-rw-r--r--src/render/pass/SurfacePassElement.cpp4
-rw-r--r--src/render/pass/TextureMatteElement.cpp1
13 files changed, 644 insertions, 708 deletions
diff --git a/src/render/OpenGL.cpp b/src/render/OpenGL.cpp
index 83ad05ca..0a54613c 100644
--- a/src/render/OpenGL.cpp
+++ b/src/render/OpenGL.cpp
@@ -389,16 +389,10 @@ CHyprOpenGLImpl::CHyprOpenGLImpl() : m_drmFD(g_pCompositor->m_drmRenderNode.fd >
initDRMFormats();
- initAssets();
-
static auto P = Event::bus()->m_events.render.pre.listen([&](PHLMONITOR mon) { preRender(mon); });
RASSERT(eglMakeCurrent(m_eglDisplay, EGL_NO_SURFACE, EGL_NO_SURFACE, EGL_NO_CONTEXT), "Couldn't unset current EGL!");
- m_globalTimer.reset();
-
- pushMonitorTransformEnabled(false);
-
static auto addLastPressToHistory = [this](const Vector2D& pos, bool killing, bool touch) {
// shift the new pos and time in
std::ranges::rotate(m_pressedHistoryPositions, m_pressedHistoryPositions.end() - 1);
@@ -676,8 +670,6 @@ void CHyprOpenGLImpl::beginSimple(PHLMONITOR pMonitor, const CRegion& damage, SP
m_renderData.monitorProjection.translate(FBO->m_size / 2.0).transform(Math::wlTransformToHyprutils(pMonitor->m_transform)).translate(-tfmd / 2.0);
}
- m_renderData.pCurrentMonData = &m_monitorRenderResources[pMonitor];
-
if (!m_shadersInitialized)
initShaders();
@@ -694,9 +686,15 @@ void CHyprOpenGLImpl::beginSimple(PHLMONITOR pMonitor, const CRegion& damage, SP
m_renderData.mainFB = m_renderData.currentFB;
m_renderData.outFB = FBO;
- m_renderData.simplePass = true;
+ g_pHyprRenderer->pushMonitorTransformEnabled(false);
+}
+
+void CHyprOpenGLImpl::makeEGLCurrent() {
+ if (!g_pCompositor || !g_pHyprOpenGL)
+ return;
- pushMonitorTransformEnabled(false);
+ if (eglGetCurrentContext() != g_pHyprOpenGL->m_eglContext)
+ eglMakeCurrent(g_pHyprOpenGL->m_eglDisplay, EGL_NO_SURFACE, EGL_NO_SURFACE, g_pHyprOpenGL->m_eglContext);
}
void CHyprOpenGLImpl::begin(PHLMONITOR pMonitor, const CRegion& damage_, SP<IFramebuffer> fb, std::optional<CRegion> finalDamage) {
@@ -723,42 +721,39 @@ void CHyprOpenGLImpl::begin(PHLMONITOR pMonitor, const CRegion& damage_, SP<IFra
m_renderData.monitorProjection = pMonitor->m_projMatrix;
- if (m_monitorRenderResources.contains(pMonitor) &&
- (!m_monitorRenderResources.at(pMonitor).offloadFB || m_monitorRenderResources.at(pMonitor).offloadFB->m_size != pMonitor->m_pixelSize))
+ if (pMonitor && (!pMonitor->m_offloadFB || pMonitor->m_offloadFB->m_size != pMonitor->m_pixelSize))
destroyMonitorResources(pMonitor);
- m_renderData.pCurrentMonData = &m_monitorRenderResources[pMonitor];
-
if (!m_shadersInitialized)
initShaders();
const auto DRM_FORMAT = fb ? fb->m_drmFormat : pMonitor->m_output->state->state().drmFormat;
// ensure a framebuffer for the monitor exists
- if (!m_renderData.pCurrentMonData->offloadFB || m_renderData.pCurrentMonData->offloadFB->m_size != pMonitor->m_pixelSize ||
- DRM_FORMAT != m_renderData.pCurrentMonData->offloadFB->m_drmFormat) {
- m_renderData.pCurrentMonData->stencilTex = g_pHyprRenderer->createStencilTexture(pMonitor->m_pixelSize.x, pMonitor->m_pixelSize.y);
- m_renderData.pCurrentMonData->offloadFB = g_pHyprRenderer->createFB();
- m_renderData.pCurrentMonData->mirrorFB = g_pHyprRenderer->createFB();
- m_renderData.pCurrentMonData->mirrorSwapFB = g_pHyprRenderer->createFB();
+ if (!m_renderData.pMonitor->m_offloadFB || m_renderData.pMonitor->m_offloadFB->m_size != pMonitor->m_pixelSize ||
+ DRM_FORMAT != m_renderData.pMonitor->m_offloadFB->m_drmFormat) {
+ m_renderData.pMonitor->m_stencilTex = g_pHyprRenderer->createStencilTexture(pMonitor->m_pixelSize.x, pMonitor->m_pixelSize.y);
+ m_renderData.pMonitor->m_offloadFB = g_pHyprRenderer->createFB();
+ m_renderData.pMonitor->m_mirrorFB = g_pHyprRenderer->createFB();
+ m_renderData.pMonitor->m_mirrorSwapFB = g_pHyprRenderer->createFB();
- m_renderData.pCurrentMonData->offloadFB->addStencil(m_renderData.pCurrentMonData->stencilTex);
- m_renderData.pCurrentMonData->mirrorFB->addStencil(m_renderData.pCurrentMonData->stencilTex);
- m_renderData.pCurrentMonData->mirrorSwapFB->addStencil(m_renderData.pCurrentMonData->stencilTex);
+ m_renderData.pMonitor->m_offloadFB->addStencil(m_renderData.pMonitor->m_stencilTex);
+ m_renderData.pMonitor->m_mirrorFB->addStencil(m_renderData.pMonitor->m_stencilTex);
+ m_renderData.pMonitor->m_mirrorSwapFB->addStencil(m_renderData.pMonitor->m_stencilTex);
- m_renderData.pCurrentMonData->offloadFB->alloc(pMonitor->m_pixelSize.x, pMonitor->m_pixelSize.y, DRM_FORMAT);
- m_renderData.pCurrentMonData->mirrorFB->alloc(pMonitor->m_pixelSize.x, pMonitor->m_pixelSize.y, DRM_FORMAT);
- m_renderData.pCurrentMonData->mirrorSwapFB->alloc(pMonitor->m_pixelSize.x, pMonitor->m_pixelSize.y, DRM_FORMAT);
+ m_renderData.pMonitor->m_offloadFB->alloc(pMonitor->m_pixelSize.x, pMonitor->m_pixelSize.y, DRM_FORMAT);
+ m_renderData.pMonitor->m_mirrorFB->alloc(pMonitor->m_pixelSize.x, pMonitor->m_pixelSize.y, DRM_FORMAT);
+ m_renderData.pMonitor->m_mirrorSwapFB->alloc(pMonitor->m_pixelSize.x, pMonitor->m_pixelSize.y, DRM_FORMAT);
}
- const bool HAS_MIRROR_FB = m_renderData.pCurrentMonData->monitorMirrorFB && m_renderData.pCurrentMonData->monitorMirrorFB->isAllocated();
+ const bool HAS_MIRROR_FB = m_renderData.pMonitor->m_monitorMirrorFB && m_renderData.pMonitor->m_monitorMirrorFB->isAllocated();
const bool NEEDS_COPY_FB = needsACopyFB(m_renderData.pMonitor.lock());
if (HAS_MIRROR_FB && !NEEDS_COPY_FB)
- m_renderData.pCurrentMonData->monitorMirrorFB->release();
- else if (!HAS_MIRROR_FB && NEEDS_COPY_FB && m_renderData.pCurrentMonData->monitorMirrorFB)
- m_renderData.pCurrentMonData->monitorMirrorFB->alloc(m_renderData.pMonitor->m_pixelSize.x, m_renderData.pMonitor->m_pixelSize.y,
- m_renderData.pMonitor->m_output->state->state().drmFormat);
+ m_renderData.pMonitor->m_monitorMirrorFB->release();
+ else if (!HAS_MIRROR_FB && NEEDS_COPY_FB && m_renderData.pMonitor->m_monitorMirrorFB)
+ m_renderData.pMonitor->m_monitorMirrorFB->alloc(m_renderData.pMonitor->m_pixelSize.x, m_renderData.pMonitor->m_pixelSize.y,
+ m_renderData.pMonitor->m_output->state->state().drmFormat);
m_renderData.transformDamage = true;
if (HAS_MIRROR_FB != NEEDS_COPY_FB) {
@@ -772,20 +767,20 @@ void CHyprOpenGLImpl::begin(PHLMONITOR pMonitor, const CRegion& damage_, SP<IFra
m_fakeFrame = fb;
- if (m_reloadScreenShader) {
- m_reloadScreenShader = false;
- static auto PSHADER = CConfigValue<std::string>("decoration:screen_shader");
+ if (g_pHyprRenderer->m_reloadScreenShader) {
+ g_pHyprRenderer->m_reloadScreenShader = false;
+ static auto PSHADER = CConfigValue<std::string>("decoration:screen_shader");
applyScreenShader(*PSHADER);
}
- m_renderData.pCurrentMonData->offloadFB->bind();
- m_renderData.currentFB = m_renderData.pCurrentMonData->offloadFB;
+ m_renderData.pMonitor->m_offloadFB->bind();
+ m_renderData.currentFB = m_renderData.pMonitor->m_offloadFB;
m_offloadedFramebuffer = true;
m_renderData.mainFB = m_renderData.currentFB;
m_renderData.outFB = fb ? fb : g_pHyprRenderer->getCurrentRBO()->getFB();
- pushMonitorTransformEnabled(false);
+ g_pHyprRenderer->pushMonitorTransformEnabled(false);
}
void CHyprOpenGLImpl::end() {
@@ -802,7 +797,7 @@ void CHyprOpenGLImpl::end() {
// end the render, copy the data to the main framebuffer
if LIKELY (m_offloadedFramebuffer) {
m_renderData.damage = m_renderData.finalDamage;
- pushMonitorTransformEnabled(true);
+ g_pHyprRenderer->pushMonitorTransformEnabled(true);
CBox monbox = {0, 0, m_renderData.pMonitor->m_transformedSize.x, m_renderData.pMonitor->m_transformedSize.y};
@@ -826,33 +821,33 @@ void CHyprOpenGLImpl::end() {
m_finalScreenShader->program() >= 1 || g_pHyprRenderer->m_crashingInProgress || m_renderData.pMonitor->m_imageDescription->value() != SImageDescription{};
if LIKELY (!PRIMITIVE_BLOCKED || g_pHyprRenderer->m_renderMode != RENDER_MODE_NORMAL)
- renderTexturePrimitive(m_renderData.pCurrentMonData->offloadFB->getTexture(), monbox);
+ renderTexturePrimitive(m_renderData.pMonitor->m_offloadFB->getTexture(), monbox);
else // we need to use renderTexture if we do any CM whatsoever.
- renderTexture(m_renderData.pCurrentMonData->offloadFB->getTexture(), monbox, {.finalMonitorCM = true});
+ renderTexture(m_renderData.pMonitor->m_offloadFB->getTexture(), monbox, {.finalMonitorCM = true});
blend(true);
m_renderData.useNearestNeighbor = false;
m_applyFinalShader = false;
- popMonitorTransformEnabled();
+ g_pHyprRenderer->popMonitorTransformEnabled();
}
// invalidate our render FBs to signal to the driver we don't need them anymore
- if (m_renderData.pCurrentMonData->mirrorFB) {
- m_renderData.pCurrentMonData->mirrorFB->bind();
- GLFB(m_renderData.pCurrentMonData->mirrorFB)->invalidate({GL_STENCIL_ATTACHMENT, GL_COLOR_ATTACHMENT0});
+ if (m_renderData.pMonitor->m_mirrorFB) {
+ m_renderData.pMonitor->m_mirrorFB->bind();
+ GLFB(m_renderData.pMonitor->m_mirrorFB)->invalidate({GL_STENCIL_ATTACHMENT, GL_COLOR_ATTACHMENT0});
}
- if (m_renderData.pCurrentMonData->mirrorSwapFB) {
- m_renderData.pCurrentMonData->mirrorSwapFB->bind();
- GLFB(m_renderData.pCurrentMonData->mirrorSwapFB)->invalidate({GL_STENCIL_ATTACHMENT, GL_COLOR_ATTACHMENT0});
+ if (m_renderData.pMonitor->m_mirrorSwapFB) {
+ m_renderData.pMonitor->m_mirrorSwapFB->bind();
+ GLFB(m_renderData.pMonitor->m_mirrorSwapFB)->invalidate({GL_STENCIL_ATTACHMENT, GL_COLOR_ATTACHMENT0});
}
- if (m_renderData.pCurrentMonData->offloadFB) {
- m_renderData.pCurrentMonData->offloadFB->bind();
- GLFB(m_renderData.pCurrentMonData->offloadFB)->invalidate({GL_STENCIL_ATTACHMENT, GL_COLOR_ATTACHMENT0});
+ if (m_renderData.pMonitor->m_offloadFB) {
+ m_renderData.pMonitor->m_offloadFB->bind();
+ GLFB(m_renderData.pMonitor->m_offloadFB)->invalidate({GL_STENCIL_ATTACHMENT, GL_COLOR_ATTACHMENT0});
}
- if (m_renderData.pCurrentMonData->offMainFB) {
- m_renderData.pCurrentMonData->offMainFB->bind();
- GLFB(m_renderData.pCurrentMonData->offMainFB)->invalidate({GL_STENCIL_ATTACHMENT, GL_COLOR_ATTACHMENT0});
+ if (m_renderData.pMonitor->m_offMainFB) {
+ m_renderData.pMonitor->m_offMainFB->bind();
+ GLFB(m_renderData.pMonitor->m_offMainFB)->invalidate({GL_STENCIL_ATTACHMENT, GL_COLOR_ATTACHMENT0});
}
// reset our data
@@ -863,13 +858,13 @@ void CHyprOpenGLImpl::end() {
m_renderData.currentFB = nullptr;
m_renderData.mainFB = nullptr;
m_renderData.outFB = nullptr;
- popMonitorTransformEnabled();
+ g_pHyprRenderer->popMonitorTransformEnabled();
// if we dropped to offMain, release it now.
// if there is a plugin constantly using it, this might be a bit slow,
// but I haven't seen a single plugin yet use these, so it's better to drop a bit of vram.
- if UNLIKELY (m_renderData.pCurrentMonData->offMainFB && m_renderData.pCurrentMonData->offMainFB->isAllocated())
- m_renderData.pCurrentMonData->offMainFB->release();
+ if UNLIKELY (m_renderData.pMonitor && m_renderData.pMonitor->m_offMainFB && m_renderData.pMonitor->m_offMainFB->isAllocated())
+ m_renderData.pMonitor->m_offMainFB->release();
static const auto GLDEBUG = CConfigValue<Hyprlang::INT>("debug:gl_debugging");
@@ -960,7 +955,7 @@ void CHyprOpenGLImpl::applyScreenShader(const std::string& path) {
}
if (m_finalScreenShader->getUniformLocation(SHADER_TIME) != -1)
- m_finalScreenShader->setInitialTime(m_globalTimer.getSeconds());
+ m_finalScreenShader->setInitialTime(g_pHyprRenderer->m_globalTimer.getSeconds());
static auto uniformRequireNoDamage = [this](eShaderUniform uniform, const std::string& name) {
if (*PDT == 0)
@@ -1079,17 +1074,17 @@ void CHyprOpenGLImpl::renderRectWithBlurInternal(const CBox& box, const CHyprCol
CRegion damage{m_renderData.damage};
damage.intersect(box);
- auto POUTFB = data.xray ? m_renderData.pCurrentMonData->blurFB : blurMainFramebufferWithDamage(data.blurA, &damage);
+ auto POUTFB = data.xray ? m_renderData.pMonitor->m_blurFB : blurMainFramebufferWithDamage(data.blurA, &damage);
m_renderData.currentFB->bind();
CBox MONITORBOX = {0, 0, m_renderData.pMonitor->m_transformedSize.x, m_renderData.pMonitor->m_transformedSize.y};
- pushMonitorTransformEnabled(true);
+ g_pHyprRenderer->pushMonitorTransformEnabled(true);
const auto SAVEDRENDERMODIF = m_renderData.renderModif;
m_renderData.renderModif = {}; // fix shit
renderTexture(POUTFB->getTexture(), MONITORBOX,
STextureRenderData{.damage = &damage, .a = data.blurA, .round = data.round, .roundingPower = 2.F, .allowCustomUV = false, .allowDim = false, .noAA = false});
- popMonitorTransformEnabled();
+ g_pHyprRenderer->popMonitorTransformEnabled();
m_renderData.renderModif = SAVEDRENDERMODIF;
renderRectWithDamageInternal(box, col, data);
@@ -1105,7 +1100,8 @@ void CHyprOpenGLImpl::renderRectWithDamageInternal(const CBox& box, const CHyprC
m_renderData.renderModif.applyToBox(newBox);
Mat3x3 matrix = m_renderData.monitorProjection.projectBox(
- newBox, Math::wlTransformToHyprutils(Math::invertTransform(!m_monitorTransformEnabled ? WL_OUTPUT_TRANSFORM_NORMAL : m_renderData.pMonitor->m_transform)), newBox.rot);
+ newBox, Math::wlTransformToHyprutils(Math::invertTransform(!g_pHyprRenderer->m_monitorTransformEnabled ? WL_OUTPUT_TRANSFORM_NORMAL : m_renderData.pMonitor->m_transform)),
+ newBox.rot);
Mat3x3 glMatrix = m_renderData.projection.copy().multiply(matrix);
auto shader = useShader(getShaderVariant(SH_FRAG_QUAD, data.round > 0 ? SH_FEAT_ROUNDING : 0));
@@ -1249,7 +1245,7 @@ WP<CShader> CHyprOpenGLImpl::renderToOutputInternal() {
shader = useShader(shader);
if (*PDT == 0 || g_pHyprRenderer->m_crashingInProgress)
- shader->setUniformFloat(SHADER_TIME, m_globalTimer.getSeconds() - shader->getInitialTime());
+ shader->setUniformFloat(SHADER_TIME, g_pHyprRenderer->m_globalTimer.getSeconds() - shader->getInitialTime());
else
shader->setUniformFloat(SHADER_TIME, 0.f);
@@ -1491,7 +1487,7 @@ void CHyprOpenGLImpl::renderTextureInternal(SP<ITexture> tex, const CBox& box, c
const auto MONITOR_INVERTED = Math::wlTransformToHyprutils(Math::invertTransform(m_renderData.pMonitor->m_transform));
Hyprutils::Math::eTransform TRANSFORM = tex->m_transform;
- if (m_monitorTransformEnabled)
+ if (g_pHyprRenderer->monitorTransformEnabled())
TRANSFORM = Math::composeTransform(MONITOR_INVERTED, TRANSFORM);
Mat3x3 matrix = m_renderData.monitorProjection.projectBox(newBox, TRANSFORM, newBox.rot);
@@ -1586,9 +1582,10 @@ void CHyprOpenGLImpl::renderTexturePrimitive(SP<ITexture> tex, const CBox& box)
m_renderData.renderModif.applyToBox(newBox);
// get transform
- const auto TRANSFORM = Math::wlTransformToHyprutils(Math::invertTransform(!m_monitorTransformEnabled ? WL_OUTPUT_TRANSFORM_NORMAL : m_renderData.pMonitor->m_transform));
- Mat3x3 matrix = m_renderData.monitorProjection.projectBox(newBox, TRANSFORM, newBox.rot);
- Mat3x3 glMatrix = m_renderData.projection.copy().multiply(matrix);
+ const auto TRANSFORM =
+ Math::wlTransformToHyprutils(Math::invertTransform(!g_pHyprRenderer->m_monitorTransformEnabled ? WL_OUTPUT_TRANSFORM_NORMAL : m_renderData.pMonitor->m_transform));
+ Mat3x3 matrix = m_renderData.monitorProjection.projectBox(newBox, TRANSFORM, newBox.rot);
+ Mat3x3 glMatrix = m_renderData.projection.copy().multiply(matrix);
glActiveTexture(GL_TEXTURE0);
tex->bind();
@@ -1631,11 +1628,12 @@ void CHyprOpenGLImpl::renderTextureMatte(SP<ITexture> tex, const CBox& box, SP<I
m_renderData.renderModif.applyToBox(newBox);
// get transform
- const auto TRANSFORM = Math::wlTransformToHyprutils(Math::invertTransform(!m_monitorTransformEnabled ? WL_OUTPUT_TRANSFORM_NORMAL : m_renderData.pMonitor->m_transform));
- Mat3x3 matrix = m_renderData.monitorProjection.projectBox(newBox, TRANSFORM, newBox.rot);
- Mat3x3 glMatrix = m_renderData.projection.copy().multiply(matrix);
+ const auto TRANSFORM =
+ Math::wlTransformToHyprutils(Math::invertTransform(!g_pHyprRenderer->m_monitorTransformEnabled ? WL_OUTPUT_TRANSFORM_NORMAL : m_renderData.pMonitor->m_transform));
+ Mat3x3 matrix = m_renderData.monitorProjection.projectBox(newBox, TRANSFORM, newBox.rot);
+ Mat3x3 glMatrix = m_renderData.projection.copy().multiply(matrix);
- auto shader = useShader(getShaderVariant(SH_FRAG_MATTE));
+ auto shader = useShader(getShaderVariant(SH_FRAG_MATTE));
shader->setUniformMatrix3fv(SHADER_PROJ, 1, GL_TRUE, glMatrix.getMatrix());
shader->setUniformInt(SHADER_TEX, 0);
shader->setUniformInt(SHADER_ALPHA_MATTE, 1);
@@ -1666,7 +1664,7 @@ void CHyprOpenGLImpl::renderTextureMatte(SP<ITexture> tex, const CBox& box, SP<I
SP<IFramebuffer> CHyprOpenGLImpl::blurMainFramebufferWithDamage(float a, CRegion* originalDamage) {
if (!m_renderData.currentFB->getTexture()) {
Log::logger->log(Log::ERR, "BUG THIS: null fb texture while attempting to blur main fb?! (introspection off?!)");
- return m_renderData.pCurrentMonData->mirrorFB; // return something to sample from at least
+ return m_renderData.pMonitor->m_mirrorFB; // return something to sample from at least
}
return blurFramebufferWithDamage(a, originalDamage, *GLFB(m_renderData.currentFB));
@@ -1700,8 +1698,8 @@ SP<IFramebuffer> CHyprOpenGLImpl::blurFramebufferWithDamage(float a, CRegion* or
damage.expand(std::clamp(*PBLURSIZE, sc<int64_t>(1), sc<int64_t>(40)) * pow(2, BLUR_PASSES));
// helper
- const auto PMIRRORFB = m_renderData.pCurrentMonData->mirrorFB;
- const auto PMIRRORSWAPFB = m_renderData.pCurrentMonData->mirrorSwapFB;
+ const auto PMIRRORFB = m_renderData.pMonitor->m_mirrorFB;
+ const auto PMIRRORSWAPFB = m_renderData.pMonitor->m_mirrorSwapFB;
auto currentRenderToFB = PMIRRORFB;
@@ -1876,16 +1874,12 @@ SP<IFramebuffer> CHyprOpenGLImpl::blurFramebufferWithDamage(float a, CRegion* or
return currentRenderToFB;
}
-void CHyprOpenGLImpl::markBlurDirtyForMonitor(PHLMONITOR pMonitor) {
- m_monitorRenderResources[pMonitor].blurFBDirty = true;
-}
-
void CHyprOpenGLImpl::preRender(PHLMONITOR pMonitor) {
static auto PBLURNEWOPTIMIZE = CConfigValue<Hyprlang::INT>("decoration:blur:new_optimizations");
static auto PBLURXRAY = CConfigValue<Hyprlang::INT>("decoration:blur:xray");
static auto PBLUR = CConfigValue<Hyprlang::INT>("decoration:blur:enabled");
- if (!*PBLURNEWOPTIMIZE || !m_monitorRenderResources[pMonitor].blurFBDirty || !*PBLUR)
+ if (!*PBLURNEWOPTIMIZE || !pMonitor->m_blurFBDirty || !*PBLUR)
return;
// ignore if solitary present, nothing to blur
@@ -1960,7 +1954,7 @@ void CHyprOpenGLImpl::preRender(PHLMONITOR pMonitor) {
return;
g_pHyprRenderer->damageMonitor(pMonitor);
- m_monitorRenderResources[pMonitor].blurFBShouldRender = true;
+ pMonitor->m_blurFBShouldRender = true;
}
void CHyprOpenGLImpl::preBlurForCurrentMonitor() {
@@ -1975,27 +1969,26 @@ void CHyprOpenGLImpl::preBlurForCurrentMonitor() {
const auto POUTFB = blurMainFramebufferWithDamage(1, &fakeDamage);
// render onto blurFB
- if (!m_renderData.pCurrentMonData->blurFB)
- m_renderData.pCurrentMonData->blurFB = g_pHyprRenderer->createFB();
+ if (!m_renderData.pMonitor->m_blurFB)
+ m_renderData.pMonitor->m_blurFB = g_pHyprRenderer->createFB();
- m_renderData.pCurrentMonData->blurFB->alloc(m_renderData.pMonitor->m_pixelSize.x, m_renderData.pMonitor->m_pixelSize.y,
- m_renderData.pMonitor->m_output->state->state().drmFormat);
- m_renderData.pCurrentMonData->blurFB->bind();
+ m_renderData.pMonitor->m_blurFB->alloc(m_renderData.pMonitor->m_pixelSize.x, m_renderData.pMonitor->m_pixelSize.y, m_renderData.pMonitor->m_output->state->state().drmFormat);
+ m_renderData.pMonitor->m_blurFB->bind();
clear(CHyprColor(0, 0, 0, 0));
- pushMonitorTransformEnabled(true);
+ g_pHyprRenderer->pushMonitorTransformEnabled(true);
renderTextureInternal(POUTFB->getTexture(), CBox{0, 0, m_renderData.pMonitor->m_transformedSize.x, m_renderData.pMonitor->m_transformedSize.y},
STextureRenderData{.damage = &fakeDamage, .a = 1, .round = 0, .roundingPower = 2.F, .discardActive = false, .allowCustomUV = false, .noAA = true});
- popMonitorTransformEnabled();
+ g_pHyprRenderer->popMonitorTransformEnabled();
m_renderData.currentFB->bind();
- m_renderData.pCurrentMonData->blurFBDirty = false;
+ m_renderData.pMonitor->m_blurFBDirty = false;
m_renderData.renderModif = SAVEDRENDERMODIF;
- m_monitorRenderResources[m_renderData.pMonitor].blurFBShouldRender = false;
+ m_renderData.pMonitor->m_blurFBShouldRender = false;
}
void CHyprOpenGLImpl::preWindowPass() {
@@ -2009,29 +2002,7 @@ bool CHyprOpenGLImpl::preBlurQueued() {
static auto PBLURNEWOPTIMIZE = CConfigValue<Hyprlang::INT>("decoration:blur:new_optimizations");
static auto PBLUR = CConfigValue<Hyprlang::INT>("decoration:blur:enabled");
- return m_renderData.pCurrentMonData->blurFBDirty && *PBLURNEWOPTIMIZE && *PBLUR && m_renderData.pCurrentMonData->blurFBShouldRender;
-}
-
-bool CHyprOpenGLImpl::shouldUseNewBlurOptimizations(PHLLS pLayer, PHLWINDOW pWindow) {
- static auto PBLURNEWOPTIMIZE = CConfigValue<Hyprlang::INT>("decoration:blur:new_optimizations");
- static auto PBLURXRAY = CConfigValue<Hyprlang::INT>("decoration:blur:xray");
-
- if (!m_renderData.pCurrentMonData->blurFB || !m_renderData.pCurrentMonData->blurFB->getTexture())
- return false;
-
- if (pWindow && pWindow->m_ruleApplicator->xray().hasValue() && !pWindow->m_ruleApplicator->xray().valueOrDefault())
- return false;
-
- if (pLayer && pLayer->m_ruleApplicator->xray().valueOrDefault() == 0)
- return false;
-
- if ((*PBLURNEWOPTIMIZE && pWindow && !pWindow->m_isFloating && !pWindow->onSpecialWorkspace()) || *PBLURXRAY)
- return true;
-
- if ((pLayer && pLayer->m_ruleApplicator->xray().valueOrDefault() == 1) || (pWindow && pWindow->m_ruleApplicator->xray().valueOrDefault()))
- return true;
-
- return false;
+ return m_renderData.pMonitor->m_blurFBDirty && *PBLURNEWOPTIMIZE && *PBLUR && m_renderData.pMonitor->m_blurFBShouldRender;
}
void CHyprOpenGLImpl::renderTextureWithBlurInternal(SP<ITexture> tex, const CBox& box, const STextureRenderData& data) {
@@ -2074,7 +2045,7 @@ void CHyprOpenGLImpl::renderTextureWithBlurInternal(SP<ITexture> tex, const CBox
inverseOpaque.scale(m_renderData.pMonitor->m_scale);
// vvv TODO: layered blur fbs?
- const bool USENEWOPTIMIZE = shouldUseNewBlurOptimizations(m_renderData.currentLS.lock(), m_renderData.currentWindow.lock()) && !data.blockBlurOptimization;
+ const bool USENEWOPTIMIZE = g_pHyprRenderer->shouldUseNewBlurOptimizations(m_renderData.currentLS.lock(), m_renderData.currentWindow.lock()) && !data.blockBlurOptimization;
SP<IFramebuffer> POUTFB = nullptr;
if (!USENEWOPTIMIZE) {
@@ -2083,7 +2054,7 @@ void CHyprOpenGLImpl::renderTextureWithBlurInternal(SP<ITexture> tex, const CBox
inverseOpaque.intersect(texDamage);
POUTFB = blurMainFramebufferWithDamage(data.a, &inverseOpaque);
} else
- POUTFB = m_renderData.pCurrentMonData->blurFB;
+ POUTFB = m_renderData.pMonitor->m_blurFB;
m_renderData.currentFB->bind();
@@ -2135,7 +2106,7 @@ void CHyprOpenGLImpl::renderTextureWithBlurInternal(SP<ITexture> tex, const CBox
m_renderData.primarySurfaceUVBottomRight = (monitorSpaceBox.pos() + monitorSpaceBox.size()) / m_renderData.pMonitor->m_transformedSize;
static auto PBLURIGNOREOPACITY = CConfigValue<Hyprlang::INT>("decoration:blur:ignore_opacity");
- pushMonitorTransformEnabled(true);
+ g_pHyprRenderer->pushMonitorTransformEnabled(true);
bool renderModif = m_renderData.renderModif.enabled;
if (!USENEWOPTIMIZE)
setRenderModifEnabled(false);
@@ -2153,7 +2124,7 @@ void CHyprOpenGLImpl::renderTextureWithBlurInternal(SP<ITexture> tex, const CBox
});
if (!USENEWOPTIMIZE)
setRenderModifEnabled(renderModif);
- popMonitorTransformEnabled();
+ g_pHyprRenderer->popMonitorTransformEnabled();
if (NEEDS_STENCIL)
setCapStatus(GL_STENCIL_TEST, false);
@@ -2210,7 +2181,8 @@ void CHyprOpenGLImpl::renderBorder(const CBox& box, const CGradientValueData& gr
float round = data.round + (data.round == 0 ? 0 : scaledBorderSize);
Mat3x3 matrix = m_renderData.monitorProjection.projectBox(
- newBox, Math::wlTransformToHyprutils(Math::invertTransform(!m_monitorTransformEnabled ? WL_OUTPUT_TRANSFORM_NORMAL : m_renderData.pMonitor->m_transform)), newBox.rot);
+ newBox, Math::wlTransformToHyprutils(Math::invertTransform(!g_pHyprRenderer->m_monitorTransformEnabled ? WL_OUTPUT_TRANSFORM_NORMAL : m_renderData.pMonitor->m_transform)),
+ newBox.rot);
Mat3x3 glMatrix = m_renderData.projection.copy().multiply(matrix);
const auto BLEND = m_blend;
@@ -2297,7 +2269,8 @@ void CHyprOpenGLImpl::renderBorder(const CBox& box, const CGradientValueData& gr
float round = data.round + (data.round == 0 ? 0 : scaledBorderSize);
Mat3x3 matrix = m_renderData.monitorProjection.projectBox(
- newBox, Math::wlTransformToHyprutils(Math::invertTransform(!m_monitorTransformEnabled ? WL_OUTPUT_TRANSFORM_NORMAL : m_renderData.pMonitor->m_transform)), newBox.rot);
+ newBox, Math::wlTransformToHyprutils(Math::invertTransform(!g_pHyprRenderer->m_monitorTransformEnabled ? WL_OUTPUT_TRANSFORM_NORMAL : m_renderData.pMonitor->m_transform)),
+ newBox.rot);
Mat3x3 glMatrix = m_renderData.projection.copy().multiply(matrix);
const auto BLEND = m_blend;
@@ -2378,7 +2351,8 @@ void CHyprOpenGLImpl::renderRoundedShadow(const CBox& box, int round, float roun
const auto col = color;
Mat3x3 matrix = m_renderData.monitorProjection.projectBox(
- newBox, Math::wlTransformToHyprutils(Math::invertTransform(!m_monitorTransformEnabled ? WL_OUTPUT_TRANSFORM_NORMAL : m_renderData.pMonitor->m_transform)), newBox.rot);
+ newBox, Math::wlTransformToHyprutils(Math::invertTransform(!g_pHyprRenderer->m_monitorTransformEnabled ? WL_OUTPUT_TRANSFORM_NORMAL : m_renderData.pMonitor->m_transform)),
+ newBox.rot);
Mat3x3 glMatrix = m_renderData.projection.copy().multiply(matrix);
blend(true);
@@ -2428,14 +2402,14 @@ void CHyprOpenGLImpl::renderRoundedShadow(const CBox& box, int round, float roun
}
void CHyprOpenGLImpl::saveBufferForMirror(const CBox& box) {
- if (!m_renderData.pCurrentMonData->monitorMirrorFB)
- m_renderData.pCurrentMonData->monitorMirrorFB = g_pHyprRenderer->createFB();
+ if (!m_renderData.pMonitor->m_monitorMirrorFB)
+ m_renderData.pMonitor->m_monitorMirrorFB = g_pHyprRenderer->createFB();
- if (!m_renderData.pCurrentMonData->monitorMirrorFB->isAllocated())
- m_renderData.pCurrentMonData->monitorMirrorFB->alloc(m_renderData.pMonitor->m_pixelSize.x, m_renderData.pMonitor->m_pixelSize.y,
- m_renderData.pMonitor->m_output->state->state().drmFormat);
+ if (!m_renderData.pMonitor->m_monitorMirrorFB->isAllocated())
+ m_renderData.pMonitor->m_monitorMirrorFB->alloc(m_renderData.pMonitor->m_pixelSize.x, m_renderData.pMonitor->m_pixelSize.y,
+ m_renderData.pMonitor->m_output->state->state().drmFormat);
- m_renderData.pCurrentMonData->monitorMirrorFB->bind();
+ m_renderData.pMonitor->m_monitorMirrorFB->bind();
blend(false);
@@ -2468,7 +2442,7 @@ void CHyprOpenGLImpl::renderMirrored() {
monbox.x = (monitor->m_transformedSize.x - monbox.w) / 2;
monbox.y = (monitor->m_transformedSize.y - monbox.h) / 2;
- auto PFB = m_monitorRenderResources[mirrored].monitorMirrorFB;
+ auto PFB = mirrored->m_monitorMirrorFB;
if (!PFB->isAllocated() || !PFB->getTexture())
return;
@@ -2521,49 +2495,6 @@ void CHyprOpenGLImpl::renderSplash(cairo_t* const CAIRO, cairo_surface_t* const
cairo_surface_flush(CAIROSURFACE);
}
-std::string CHyprOpenGLImpl::resolveAssetPath(const std::string& filename) {
- std::string fullPath;
- for (auto& e : ASSET_PATHS) {
- std::string p = std::string{e} + "/hypr/" + filename;
- std::error_code ec;
- if (std::filesystem::exists(p, ec)) {
- fullPath = p;
- break;
- } else
- Log::logger->log(Log::DEBUG, "resolveAssetPath: looking at {} unsuccessful: ec {}", filename, ec.message());
- }
-
- if (fullPath.empty()) {
- m_failedAssetsNo++;
- Log::logger->log(Log::ERR, "resolveAssetPath: looking for {} failed (no provider found)", filename);
- return "";
- }
-
- return fullPath;
-}
-
-SP<ITexture> CHyprOpenGLImpl::loadAsset(const std::string& filename) {
-
- const std::string fullPath = resolveAssetPath(filename);
-
- if (fullPath.empty())
- return m_missingAssetTexture;
-
- const auto CAIROSURFACE = cairo_image_surface_create_from_png(fullPath.c_str());
-
- if (!CAIROSURFACE) {
- m_failedAssetsNo++;
- Log::logger->log(Log::ERR, "loadAsset: failed to load {} (corrupt / inaccessible / not png)", fullPath);
- return m_missingAssetTexture;
- }
-
- auto tex = texFromCairo(CAIROSURFACE);
-
- cairo_surface_destroy(CAIROSURFACE);
-
- return tex;
-}
-
SP<ITexture> CHyprOpenGLImpl::texFromCairo(cairo_surface_t* cairo) {
const auto CAIROFORMAT = cairo_image_surface_get_format(cairo);
auto tex = makeShared<CGLTexture>();
@@ -2589,126 +2520,6 @@ SP<ITexture> CHyprOpenGLImpl::texFromCairo(cairo_surface_t* cairo) {
return tex;
}
-SP<ITexture> CHyprOpenGLImpl::renderText(const std::string& text, CHyprColor col, int pt, bool italic, const std::string& fontFamily, int maxWidth, int weight) {
- SP<ITexture> tex = makeShared<CGLTexture>();
-
- static auto FONT = CConfigValue<std::string>("misc:font_family");
-
- const auto FONTFAMILY = fontFamily.empty() ? *FONT : fontFamily;
- const auto FONTSIZE = pt;
- const auto COLOR = col;
-
- auto CAIROSURFACE = cairo_image_surface_create(CAIRO_FORMAT_ARGB32, 1920, 1080 /* arbitrary, just for size */);
- auto CAIRO = cairo_create(CAIROSURFACE);
-
- PangoLayout* layoutText = pango_cairo_create_layout(CAIRO);
- PangoFontDescription* pangoFD = pango_font_description_new();
-
- pango_font_description_set_family_static(pangoFD, FONTFAMILY.c_str());
- pango_font_description_set_absolute_size(pangoFD, FONTSIZE * PANGO_SCALE);
- pango_font_description_set_style(pangoFD, italic ? PANGO_STYLE_ITALIC : PANGO_STYLE_NORMAL);
- pango_font_description_set_weight(pangoFD, sc<PangoWeight>(weight));
- pango_layout_set_font_description(layoutText, pangoFD);
-
- cairo_set_source_rgba(CAIRO, COLOR.r, COLOR.g, COLOR.b, COLOR.a);
-
- int textW = 0, textH = 0;
- pango_layout_set_text(layoutText, text.c_str(), -1);
-
- if (maxWidth > 0) {
- pango_layout_set_width(layoutText, maxWidth * PANGO_SCALE);
- pango_layout_set_ellipsize(layoutText, PANGO_ELLIPSIZE_END);
- }
-
- pango_layout_get_size(layoutText, &textW, &textH);
- textW /= PANGO_SCALE;
- textH /= PANGO_SCALE;
-
- pango_font_description_free(pangoFD);
- g_object_unref(layoutText);
- cairo_destroy(CAIRO);
- cairo_surface_destroy(CAIROSURFACE);
-
- CAIROSURFACE = cairo_image_surface_create(CAIRO_FORMAT_ARGB32, textW, textH);
- CAIRO = cairo_create(CAIROSURFACE);
-
- layoutText = pango_cairo_create_layout(CAIRO);
- pangoFD = pango_font_description_new();
-
- pango_font_description_set_family_static(pangoFD, FONTFAMILY.c_str());
- pango_font_description_set_absolute_size(pangoFD, FONTSIZE * PANGO_SCALE);
- pango_font_description_set_style(pangoFD, italic ? PANGO_STYLE_ITALIC : PANGO_STYLE_NORMAL);
- pango_font_description_set_weight(pangoFD, sc<PangoWeight>(weight));
- pango_layout_set_font_description(layoutText, pangoFD);
- pango_layout_set_text(layoutText, text.c_str(), -1);
-
- cairo_set_source_rgba(CAIRO, COLOR.r, COLOR.g, COLOR.b, COLOR.a);
-
- cairo_move_to(CAIRO, 0, 0);
- pango_cairo_show_layout(CAIRO, layoutText);
-
- pango_font_description_free(pangoFD);
- g_object_unref(layoutText);
-
- cairo_surface_flush(CAIROSURFACE);
-
- tex->allocate({cairo_image_surface_get_width(CAIROSURFACE), cairo_image_surface_get_height(CAIROSURFACE)});
-
- const auto DATA = cairo_image_surface_get_data(CAIROSURFACE);
- tex->bind();
- tex->setTexParameter(GL_TEXTURE_MAG_FILTER, GL_LINEAR);
- tex->setTexParameter(GL_TEXTURE_MIN_FILTER, GL_LINEAR);
- tex->setTexParameter(GL_TEXTURE_SWIZZLE_R, GL_BLUE);
- tex->setTexParameter(GL_TEXTURE_SWIZZLE_B, GL_RED);
- glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, tex->m_size.x, tex->m_size.y, 0, GL_RGBA, GL_UNSIGNED_BYTE, DATA);
-
- cairo_destroy(CAIRO);
- cairo_surface_destroy(CAIROSURFACE);
-
- return tex;
-}
-
-void CHyprOpenGLImpl::initMissingAssetTexture() {
- SP<ITexture> tex = makeShared<CGLTexture>();
- tex->allocate({512, 512});
-
- const auto CAIROSURFACE = cairo_image_surface_create(CAIRO_FORMAT_ARGB32, 512, 512);
- const auto CAIRO = cairo_create(CAIROSURFACE);
-
- cairo_set_antialias(CAIRO, CAIRO_ANTIALIAS_NONE);
- cairo_save(CAIRO);
- cairo_set_source_rgba(CAIRO, 0, 0, 0, 1);
- cairo_set_operator(CAIRO, CAIRO_OPERATOR_SOURCE);
- cairo_paint(CAIRO);
- cairo_set_source_rgba(CAIRO, 1, 0, 1, 1);
- cairo_rectangle(CAIRO, 256, 0, 256, 256);
- cairo_fill(CAIRO);
- cairo_rectangle(CAIRO, 0, 256, 256, 256);
- cairo_fill(CAIRO);
- cairo_restore(CAIRO);
-
- cairo_surface_flush(CAIROSURFACE);
-
- tex->m_size = {512, 512};
-
- // copy the data to an OpenGL texture we have
- const GLint glFormat = GL_RGBA;
- const GLint glType = GL_UNSIGNED_BYTE;
-
- const auto DATA = cairo_image_surface_get_data(CAIROSURFACE);
- tex->bind();
- tex->setTexParameter(GL_TEXTURE_MAG_FILTER, GL_LINEAR);
- tex->setTexParameter(GL_TEXTURE_MIN_FILTER, GL_LINEAR);
- tex->setTexParameter(GL_TEXTURE_SWIZZLE_R, GL_BLUE);
- tex->setTexParameter(GL_TEXTURE_SWIZZLE_B, GL_RED);
- glTexImage2D(GL_TEXTURE_2D, 0, glFormat, tex->m_size.x, tex->m_size.y, 0, glFormat, glType, DATA);
-
- cairo_surface_destroy(CAIROSURFACE);
- cairo_destroy(CAIRO);
-
- m_missingAssetTexture = tex;
-}
-
WP<CShader> CHyprOpenGLImpl::useShader(WP<CShader> prog) {
if (m_currentProgram == prog->program())
return prog;
@@ -2719,89 +2530,6 @@ WP<CShader> CHyprOpenGLImpl::useShader(WP<CShader> prog) {
return prog;
}
-void CHyprOpenGLImpl::initAssets() {
- initMissingAssetTexture();
-
- m_screencopyDeniedTexture = renderText("Permission denied to share screen", Colors::WHITE, 20);
-}
-
-void CHyprOpenGLImpl::ensureLockTexturesRendered(bool load) {
- static bool loaded = false;
-
- if (loaded == load)
- return;
-
- loaded = load;
-
- if (load) {
- // this will cause a small hitch. I don't think we can do much, other than wasting VRAM and having this loaded all the time.
- m_lockDeadTexture = loadAsset("lockdead.png");
- m_lockDead2Texture = loadAsset("lockdead2.png");
-
- const auto VT = g_pCompositor->getVTNr();
-
- m_lockTtyTextTexture = renderText(std::format("Running on tty {}", VT.has_value() ? std::to_string(*VT) : "unknown"), CHyprColor{0.9F, 0.9F, 0.9F, 0.7F}, 20, true);
- } else {
- m_lockDeadTexture.reset();
- m_lockDead2Texture.reset();
- m_lockTtyTextTexture.reset();
- }
-}
-
-void CHyprOpenGLImpl::requestBackgroundResource() {
- if (m_backgroundResource)
- return;
-
- static auto PNOWALLPAPER = CConfigValue<Hyprlang::INT>("misc:disable_hyprland_logo");
- static auto PFORCEWALLPAPER = CConfigValue<Hyprlang::INT>("misc:force_default_wallpaper");
-
- const auto FORCEWALLPAPER = std::clamp(*PFORCEWALLPAPER, sc<int64_t>(-1), sc<int64_t>(2));
-
- if (*PNOWALLPAPER)
- return;
-
- static bool once = true;
- static std::string texPath = "wall";
-
- if (once) {
- // get the adequate tex
- if (FORCEWALLPAPER == -1) {
- std::mt19937_64 engine(time(nullptr));
- std::uniform_int_distribution<> distribution(0, 2);
-
- texPath += std::to_string(distribution(engine));
- } else
- texPath += std::to_string(std::clamp(*PFORCEWALLPAPER, sc<int64_t>(0), sc<int64_t>(2)));
-
- texPath += ".png";
-
- texPath = resolveAssetPath(texPath);
-
- once = false;
- }
-
- if (texPath.empty()) {
- m_backgroundResourceFailed = true;
- return;
- }
-
- m_backgroundResource = makeAtomicShared<Hyprgraphics::CImageResource>(texPath);
-
- // doesn't have to be ASP as it's passed
- SP<CMainLoopExecutor> executor = makeShared<CMainLoopExecutor>([] {
- for (const auto& m : g_pCompositor->m_monitors) {
- g_pHyprRenderer->damageMonitor(m);
- }
- });
-
- m_backgroundResource->m_events.finished.listenStatic([executor] {
- // this is in the worker thread.
- executor->signal();
- });
-
- g_pAsyncResourceGatherer->enqueue(m_backgroundResource);
-}
-
void CHyprOpenGLImpl::createBGTextureForMonitor(PHLMONITOR pMonitor) {
RASSERT(m_renderData.pMonitor, "Tried to createBGTex without begin()!");
@@ -2810,16 +2538,16 @@ void CHyprOpenGLImpl::createBGTextureForMonitor(PHLMONITOR pMonitor) {
static auto PRENDERTEX = CConfigValue<Hyprlang::INT>("misc:disable_hyprland_logo");
static auto PNOSPLASH = CConfigValue<Hyprlang::INT>("misc:disable_splash_rendering");
- if (*PRENDERTEX || m_backgroundResourceFailed)
+ if (*PRENDERTEX || g_pHyprRenderer->m_backgroundResourceFailed)
return;
- if (!m_backgroundResource) {
+ if (!g_pHyprRenderer->m_backgroundResource) {
// queue the asset to be created
- requestBackgroundResource();
+ g_pHyprRenderer->requestBackgroundResource();
return;
}
- if (!m_backgroundResource->m_ready)
+ if (!g_pHyprRenderer->m_backgroundResource->m_ready)
return;
if (!m_monitorBGFBs.contains(pMonitor))
@@ -2876,7 +2604,7 @@ void CHyprOpenGLImpl::createBGTextureForMonitor(PHLMONITOR pMonitor) {
blend(true);
clear(CHyprColor{0, 0, 0, 1});
- SP<ITexture> backgroundTexture = texFromCairo(m_backgroundResource->m_asset.cairoSurface->cairo());
+ SP<ITexture> backgroundTexture = texFromCairo(g_pHyprRenderer->m_backgroundResource->m_asset.cairoSurface->cairo());
// first render the background
if (backgroundTexture) {
@@ -2907,7 +2635,7 @@ void CHyprOpenGLImpl::createBGTextureForMonitor(PHLMONITOR pMonitor) {
Log::logger->log(Log::DEBUG, "Background created for monitor {}", pMonitor->m_name);
// clear the resource after we're done using it
- g_pEventLoopManager->doLater([this] { m_backgroundResource.reset(); });
+ g_pEventLoopManager->doLater([this] { g_pHyprRenderer->m_backgroundResource.reset(); });
// set the animation to start for fading this background in nicely
pMonitor->m_backgroundOpacity->setValueAndWarp(0.F);
@@ -2937,23 +2665,11 @@ void CHyprOpenGLImpl::clearWithTex() {
}
void CHyprOpenGLImpl::destroyMonitorResources(PHLMONITORREF pMonitor) {
- g_pHyprRenderer->makeEGLCurrent();
+ makeEGLCurrent();
if (!g_pHyprOpenGL)
return;
- auto RESIT = g_pHyprOpenGL->m_monitorRenderResources.find(pMonitor);
- if (RESIT != g_pHyprOpenGL->m_monitorRenderResources.end()) {
- RESIT->second.mirrorFB.reset();
- RESIT->second.offloadFB.reset();
- RESIT->second.mirrorSwapFB.reset();
- RESIT->second.monitorMirrorFB.reset();
- RESIT->second.blurFB.reset();
- RESIT->second.offMainFB.reset();
- RESIT->second.stencilTex.reset();
- g_pHyprOpenGL->m_monitorRenderResources.erase(RESIT);
- }
-
auto TEXIT = g_pHyprOpenGL->m_monitorBGFBs.find(pMonitor);
if (TEXIT != g_pHyprOpenGL->m_monitorBGFBs.end()) {
TEXIT->second.reset();
@@ -2977,18 +2693,18 @@ void CHyprOpenGLImpl::restoreMatrix() {
}
void CHyprOpenGLImpl::bindOffMain() {
- if (!m_renderData.pCurrentMonData->offMainFB)
- m_renderData.pCurrentMonData->offMainFB = g_pHyprRenderer->createFB();
+ if (!m_renderData.pMonitor->m_offMainFB)
+ m_renderData.pMonitor->m_offMainFB = g_pHyprRenderer->createFB();
- if (!m_renderData.pCurrentMonData->offMainFB->isAllocated()) {
- m_renderData.pCurrentMonData->offMainFB->addStencil(m_renderData.pCurrentMonData->stencilTex);
- m_renderData.pCurrentMonData->offMainFB->alloc(m_renderData.pMonitor->m_pixelSize.x, m_renderData.pMonitor->m_pixelSize.y,
- m_renderData.pMonitor->m_output->state->state().drmFormat);
+ if (!m_renderData.pMonitor->m_offMainFB->isAllocated()) {
+ m_renderData.pMonitor->m_offMainFB->addStencil(m_renderData.pMonitor->m_stencilTex);
+ m_renderData.pMonitor->m_offMainFB->alloc(m_renderData.pMonitor->m_pixelSize.x, m_renderData.pMonitor->m_pixelSize.y,
+ m_renderData.pMonitor->m_output->state->state().drmFormat);
}
- m_renderData.pCurrentMonData->offMainFB->bind();
+ m_renderData.pMonitor->m_offMainFB->bind();
clear(CHyprColor(0, 0, 0, 0));
- m_renderData.currentFB = m_renderData.pCurrentMonData->offMainFB;
+ m_renderData.currentFB = m_renderData.pMonitor->m_offMainFB;
}
void CHyprOpenGLImpl::renderOffToMain(CGLFramebuffer* off) {
@@ -3001,16 +2717,6 @@ void CHyprOpenGLImpl::bindBackOnMain() {
m_renderData.currentFB = m_renderData.mainFB;
}
-void CHyprOpenGLImpl::pushMonitorTransformEnabled(bool enabled) {
- m_monitorTransformStack.push(enabled);
- m_monitorTransformEnabled = enabled;
-}
-
-void CHyprOpenGLImpl::popMonitorTransformEnabled() {
- m_monitorTransformStack.pop();
- m_monitorTransformEnabled = m_monitorTransformStack.top();
-}
-
void CHyprOpenGLImpl::setRenderModifEnabled(bool enabled) {
m_renderData.renderModif.enabled = enabled;
}
@@ -3056,19 +2762,6 @@ void CHyprOpenGLImpl::setCapStatus(int cap, bool status) {
}
}
-DRMFormat CHyprOpenGLImpl::getPreferredReadFormat(PHLMONITOR pMonitor) {
- static const auto PFORCE8BIT = CConfigValue<Hyprlang::INT>("misc:screencopy_force_8b");
-
- auto monFmt = pMonitor->m_output->state->state().drmFormat;
-
- if (*PFORCE8BIT)
- if (monFmt == DRM_FORMAT_BGRA1010102 || monFmt == DRM_FORMAT_ARGB2101010 || monFmt == DRM_FORMAT_XRGB2101010 || monFmt == DRM_FORMAT_BGRX1010102 ||
- monFmt == DRM_FORMAT_XBGR2101010)
- monFmt = DRM_FORMAT_XRGB8888;
-
- return monFmt;
-}
-
std::vector<uint64_t> CHyprOpenGLImpl::getDRMFormatModifiers(DRMFormat drmFormat) {
SDRMFormat format;
diff --git a/src/render/OpenGL.hpp b/src/render/OpenGL.hpp
index c9008447..aa8354dd 100644
--- a/src/render/OpenGL.hpp
+++ b/src/render/OpenGL.hpp
@@ -113,31 +113,15 @@ struct SPreparedShaders {
std::array<std::map<Render::ShaderFeatureFlags, SP<CShader>>, Render::SH_FRAG_LAST> fragVariants;
};
-struct SMonitorRenderData {
- SP<IFramebuffer> offloadFB;
- SP<IFramebuffer> mirrorFB; // these are used for some effects,
- SP<IFramebuffer> mirrorSwapFB; // etc
- SP<IFramebuffer> offMainFB;
- SP<IFramebuffer> monitorMirrorFB; // used for mirroring outputs, does not contain artifacts like offloadFB
- SP<IFramebuffer> blurFB;
-
- SP<ITexture> stencilTex = makeShared<CGLTexture>();
-
- bool blurFBDirty = true;
- bool blurFBShouldRender = false;
-};
-
struct SCurrentRenderData {
- PHLMONITORREF pMonitor;
- Mat3x3 projection;
- Mat3x3 savedProjection;
- Mat3x3 monitorProjection;
+ PHLMONITORREF pMonitor;
+ Mat3x3 projection;
+ Mat3x3 savedProjection;
+ Mat3x3 monitorProjection;
- // FIXME: raw pointer galore!
- SMonitorRenderData* pCurrentMonData = nullptr;
- SP<IFramebuffer> currentFB = nullptr; // current rendering to
- SP<IFramebuffer> mainFB = nullptr; // main to render to
- SP<IFramebuffer> outFB = nullptr; // out to render to (if offloaded, etc)
+ SP<IFramebuffer> currentFB = nullptr; // current rendering to
+ SP<IFramebuffer> mainFB = nullptr; // main to render to
+ SP<IFramebuffer> outFB = nullptr; // out to render to (if offloaded, etc)
CRegion damage;
CRegion finalDamage; // damage used for funal off -> main
@@ -230,96 +214,78 @@ class CHyprOpenGLImpl {
int outerRound = -1; /* use round */
};
- void begin(PHLMONITOR, const CRegion& damage, SP<IFramebuffer> fb = nullptr, std::optional<CRegion> finalDamage = {});
- void beginSimple(PHLMONITOR, const CRegion& damage, SP<IRenderbuffer> rb = nullptr, SP<IFramebuffer> fb = nullptr);
- void end();
-
- void renderRect(const CBox&, const CHyprColor&, SRectRenderData data);
- void renderTexture(SP<ITexture>, const CBox&, STextureRenderData data);
- void renderRoundedShadow(const CBox&, int round, float roundingPower, int range, const CHyprColor& color, float a = 1.0);
- void renderBorder(const CBox&, const CGradientValueData&, SBorderRenderData data);
- void renderBorder(const CBox&, const CGradientValueData&, const CGradientValueData&, float lerp, SBorderRenderData data);
- void renderTextureMatte(SP<ITexture> tex, const CBox& pBox, SP<IFramebuffer> matte);
- void renderTexturePrimitive(SP<ITexture> tex, const CBox& box);
-
- void pushMonitorTransformEnabled(bool enabled);
- void popMonitorTransformEnabled();
-
- void setRenderModifEnabled(bool enabled);
- void setViewport(GLint x, GLint y, GLsizei width, GLsizei height);
- void setCapStatus(int cap, bool status);
-
- void saveMatrix();
- void setMatrixScaleTranslate(const Vector2D& translate, const float& scale);
- void restoreMatrix();
-
- void blend(bool enabled);
+ void makeEGLCurrent();
+ void begin(PHLMONITOR, const CRegion& damage, SP<IFramebuffer> fb = nullptr, std::optional<CRegion> finalDamage = {});
+ void beginSimple(PHLMONITOR, const CRegion& damage, SP<IRenderbuffer> rb = nullptr, SP<IFramebuffer> fb = nullptr);
+ void end();
- bool shouldUseNewBlurOptimizations(PHLLS pLayer, PHLWINDOW pWindow);
+ void renderRect(const CBox&, const CHyprColor&, SRectRenderData data);
+ void renderTexture(SP<ITexture>, const CBox&, STextureRenderData data);
+ void renderRoundedShadow(const CBox&, int round, float roundingPower, int range, const CHyprColor& color, float a = 1.0);
+ void renderBorder(const CBox&, const CGradientValueData&, SBorderRenderData data);
+ void renderBorder(const CBox&, const CGradientValueData&, const CGradientValueData&, float lerp, SBorderRenderData data);
+ void renderTextureMatte(SP<ITexture> tex, const CBox& pBox, SP<IFramebuffer> matte);
+ void renderTexturePrimitive(SP<ITexture> tex, const CBox& box);
- void clear(const CHyprColor&);
- void clearWithTex();
- void scissor(const CBox&, bool transform = true);
- void scissor(const pixman_box32*, bool transform = true);
- void scissor(const int x, const int y, const int w, const int h, bool transform = true);
+ void setRenderModifEnabled(bool enabled);
+ void setViewport(GLint x, GLint y, GLsizei width, GLsizei height);
+ void setCapStatus(int cap, bool status);
- void destroyMonitorResources(PHLMONITORREF);
+ void saveMatrix();
+ void setMatrixScaleTranslate(const Vector2D& translate, const float& scale);
+ void restoreMatrix();
- void markBlurDirtyForMonitor(PHLMONITOR);
+ void blend(bool enabled);
- void preWindowPass();
- bool preBlurQueued();
- void preRender(PHLMONITOR);
+ void clear(const CHyprColor&);
+ void clearWithTex();
+ void scissor(const CBox&, bool transform = true);
+ void scissor(const pixman_box32*, bool transform = true);
+ void scissor(const int x, const int y, const int w, const int h, bool transform = true);
- void saveBufferForMirror(const CBox&);
- void renderMirrored();
+ void destroyMonitorResources(PHLMONITORREF);
- void applyScreenShader(const std::string& path);
+ void preWindowPass();
+ bool preBlurQueued();
+ void preRender(PHLMONITOR);
- void bindOffMain();
- void renderOffToMain(CGLFramebuffer* off);
- void bindBackOnMain();
+ void saveBufferForMirror(const CBox&);
+ void renderMirrored();
- bool needsACopyFB(PHLMONITOR mon);
+ void applyScreenShader(const std::string& path);
- std::string resolveAssetPath(const std::string& file);
- SP<ITexture> loadAsset(const std::string& file);
- SP<ITexture> texFromCairo(cairo_surface_t* cairo);
- SP<ITexture> renderText(const std::string& text, CHyprColor col, int pt, bool italic = false, const std::string& fontFamily = "", int maxWidth = 0, int weight = 400);
+ void bindOffMain();
+ void renderOffToMain(CGLFramebuffer* off);
+ void bindBackOnMain();
- void setDamage(const CRegion& damage, std::optional<CRegion> finalDamage = {});
+ SP<ITexture> texFromCairo(cairo_surface_t* cairo);
- DRMFormat getPreferredReadFormat(PHLMONITOR pMonitor);
- std::vector<SDRMFormat> getDRMFormats();
- std::vector<uint64_t> getDRMFormatModifiers(DRMFormat format);
- EGLImageKHR createEGLImage(const Aquamarine::SDMABUFAttrs& attrs);
+ bool needsACopyFB(PHLMONITOR mon);
+ void setDamage(const CRegion& damage, std::optional<CRegion> finalDamage = {});
- bool initShaders(const std::string& path = "");
+ std::vector<SDRMFormat> getDRMFormats();
+ std::vector<uint64_t> getDRMFormatModifiers(DRMFormat format);
+ EGLImageKHR createEGLImage(const Aquamarine::SDMABUFAttrs& attrs);
- WP<CShader> useShader(WP<CShader> prog);
+ bool initShaders(const std::string& path = "");
- bool explicitSyncSupported();
- WP<CShader> getShaderVariant(Render::ePreparedFragmentShader frag, Render::ShaderFeatureFlags features = 0);
+ WP<CShader> useShader(WP<CShader> prog);
- bool m_shadersInitialized = false;
- SP<SPreparedShaders> m_shaders;
+ bool explicitSyncSupported();
+ WP<CShader> getShaderVariant(Render::ePreparedFragmentShader frag, Render::ShaderFeatureFlags features = 0);
- SCurrentRenderData m_renderData;
+ bool m_shadersInitialized = false;
+ SP<SPreparedShaders> m_shaders;
- Hyprutils::OS::CFileDescriptor m_gbmFD;
- gbm_device* m_gbmDevice = nullptr;
- EGLContext m_eglContext = nullptr;
- EGLDisplay m_eglDisplay = nullptr;
- EGLDeviceEXT m_eglDevice = nullptr;
- uint m_failedAssetsNo = 0;
+ SCurrentRenderData m_renderData;
- bool m_reloadScreenShader = true; // at launch it can be set
+ Hyprutils::OS::CFileDescriptor m_gbmFD;
+ gbm_device* m_gbmDevice = nullptr;
+ EGLContext m_eglContext = nullptr;
+ EGLDisplay m_eglDisplay = nullptr;
+ EGLDeviceEXT m_eglDevice = nullptr;
- std::map<PHLWINDOWREF, SP<IFramebuffer>> m_windowFramebuffers;
- std::map<PHLLSREF, SP<IFramebuffer>> m_layerFramebuffers;
- std::map<WP<Desktop::View::CPopup>, SP<IFramebuffer>> m_popupFramebuffers;
- std::map<PHLMONITORREF, SMonitorRenderData> m_monitorRenderResources;
- std::map<PHLMONITORREF, SP<IFramebuffer>> m_monitorBGFBs;
+ std::map<PHLMONITORREF, SP<IFramebuffer>> m_monitorBGFBs;
struct {
PFNGLEGLIMAGETARGETRENDERBUFFERSTORAGEOESPROC glEGLImageTargetRenderbufferStorageOES = nullptr;
@@ -350,8 +316,6 @@ class CHyprOpenGLImpl {
bool EGL_ANDROID_native_fence_sync_ext = false;
} m_exts;
- SP<ITexture> m_screencopyDeniedTexture;
-
enum eEGLContextVersion : uint8_t {
EGL_CONTEXT_GLES_2_0 = 0,
EGL_CONTEXT_GLES_3_0,
@@ -375,40 +339,27 @@ class CHyprOpenGLImpl {
GLsizei height = 0;
} m_lastViewport;
- std::array<bool, CAP_STATUS_END> m_capStatus = {};
-
- std::vector<SDRMFormat> m_drmFormats;
- bool m_hasModifiers = false;
-
- int m_drmFD = -1;
- std::string m_extensions;
-
- bool m_fakeFrame = false;
- bool m_applyFinalShader = false;
- bool m_blend = false;
- bool m_offloadedFramebuffer = false;
- bool m_cmSupported = true;
-
- bool m_monitorTransformEnabled = false; // do not modify directly
- std::stack<bool> m_monitorTransformStack;
- SP<ITexture> m_missingAssetTexture;
- SP<ITexture> m_lockDeadTexture;
- SP<ITexture> m_lockDead2Texture;
- SP<ITexture> m_lockTtyTextTexture;
- SP<CShader> m_finalScreenShader;
- CTimer m_globalTimer;
- GLuint m_currentProgram;
- ASP<Hyprgraphics::CImageResource> m_backgroundResource;
- bool m_backgroundResourceFailed = false;
-
- void createBGTextureForMonitor(PHLMONITOR);
- void initDRMFormats();
- void initEGL(bool gbm);
- EGLDeviceEXT eglDeviceFromDRMFD(int drmFD);
- void initAssets();
- void ensureLockTexturesRendered(bool load);
- void initMissingAssetTexture();
- void requestBackgroundResource();
+ std::array<bool, CAP_STATUS_END> m_capStatus = {};
+
+ std::vector<SDRMFormat> m_drmFormats;
+ bool m_hasModifiers = false;
+
+ int m_drmFD = -1;
+ std::string m_extensions;
+
+ bool m_fakeFrame = false;
+ bool m_applyFinalShader = false;
+ bool m_blend = false;
+ bool m_offloadedFramebuffer = false;
+ bool m_cmSupported = true;
+
+ SP<CShader> m_finalScreenShader;
+ GLuint m_currentProgram;
+
+ void createBGTextureForMonitor(PHLMONITOR);
+ void initDRMFormats();
+ void initEGL(bool gbm);
+ EGLDeviceEXT eglDeviceFromDRMFD(int drmFD);
// for the final shader
std::array<CTimer, POINTER_PRESSED_HISTORY_LENGTH> m_pressedHistoryTimers = {};
diff --git a/src/render/Renderbuffer.cpp b/src/render/Renderbuffer.cpp
index bab4f73e..bf089646 100644
--- a/src/render/Renderbuffer.cpp
+++ b/src/render/Renderbuffer.cpp
@@ -1,7 +1,6 @@
#include "Renderbuffer.hpp"
#include "Framebuffer.hpp"
#include "render/Renderer.hpp"
-#include "render/gl/GLRenderbuffer.hpp"
#include <hyprutils/memory/SharedPtr.hpp>
#include <hyprutils/signal/Listener.hpp>
#include <hyprutils/signal/Signal.hpp>
@@ -9,7 +8,7 @@
#include <dlfcn.h>
IRenderbuffer::IRenderbuffer(SP<Aquamarine::IBuffer> buffer, uint32_t format) : m_hlBuffer(buffer) {
- m_listeners.destroyBuffer = buffer->events.destroy.listen([this] { g_pHyprRenderer->onRenderbufferDestroy(dc<CGLRenderbuffer*>(this)); });
+ m_listeners.destroyBuffer = buffer->events.destroy.listen([this] { g_pHyprRenderer->onRenderbufferDestroy(this); });
}
bool IRenderbuffer::good() {
diff --git a/src/render/Renderer.cpp b/src/render/Renderer.cpp
index ad4409d5..82dd4ce1 100644
--- a/src/render/Renderer.cpp
+++ b/src/render/Renderer.cpp
@@ -60,6 +60,7 @@
#include <pango/pangocairo.h>
#include <hyprutils/utils/ScopeGuard.hpp>
+#include <random>
using namespace Hyprutils::Utils;
using namespace Hyprutils::OS;
using enum NContentType::eContentType;
@@ -76,6 +77,10 @@ static int cursorTicker(void* data) {
}
CHyprRenderer::CHyprRenderer() {
+ m_globalTimer.reset();
+ pushMonitorTransformEnabled(false);
+ initAssets();
+
if (g_pCompositor->m_aqBackend->hasSession()) {
size_t drmDevices = 0;
for (auto const& dev : g_pCompositor->m_aqBackend->session->sessionDevices) {
@@ -208,6 +213,10 @@ CHyprRenderer::~CHyprRenderer() {
wl_event_source_remove(m_cursorTicker);
}
+WP<CHyprOpenGLImpl> CHyprRenderer::glBackend() {
+ return g_pHyprOpenGL;
+}
+
bool CHyprRenderer::shouldRenderWindow(PHLWINDOW pWindow, PHLMONITOR pMonitor) {
if (!pWindow->visibleOnMonitor(pMonitor))
return false;
@@ -623,7 +632,7 @@ void CHyprRenderer::renderWindow(PHLWINDOW pWindow, PHLMONITOR pMonitor, const T
data.round = renderdata.dontRound ? 0 : renderdata.rounding - 1;
data.blur = true;
data.blurA = renderdata.fadeAlpha;
- data.xray = g_pHyprOpenGL->shouldUseNewBlurOptimizations(nullptr, pWindow);
+ data.xray = shouldUseNewBlurOptimizations(nullptr, pWindow);
m_renderPass.add(makeUnique<CRectPassElement>(data));
renderdata.blur = false;
}
@@ -802,12 +811,12 @@ void CHyprRenderer::draw(CFramebufferElement* element, const CRegion& damage) {
} else {
switch (m_data.framebufferID) {
- case FB_MONITOR_RENDER_EXTRA_OFFLOAD: fb = g_pHyprOpenGL->m_renderData.pCurrentMonData->offloadFB; break;
- case FB_MONITOR_RENDER_EXTRA_MIRROR: fb = g_pHyprOpenGL->m_renderData.pCurrentMonData->mirrorFB; break;
- case FB_MONITOR_RENDER_EXTRA_MIRROR_SWAP: fb = g_pHyprOpenGL->m_renderData.pCurrentMonData->mirrorSwapFB; break;
- case FB_MONITOR_RENDER_EXTRA_OFF_MAIN: fb = g_pHyprOpenGL->m_renderData.pCurrentMonData->offMainFB; break;
- case FB_MONITOR_RENDER_EXTRA_MONITOR_MIRROR: fb = g_pHyprOpenGL->m_renderData.pCurrentMonData->monitorMirrorFB; break;
- case FB_MONITOR_RENDER_EXTRA_BLUR: fb = g_pHyprOpenGL->m_renderData.pCurrentMonData->blurFB; break;
+ case FB_MONITOR_RENDER_EXTRA_OFFLOAD: fb = g_pHyprOpenGL->m_renderData.pMonitor->m_offloadFB; break;
+ case FB_MONITOR_RENDER_EXTRA_MIRROR: fb = g_pHyprOpenGL->m_renderData.pMonitor->m_mirrorFB; break;
+ case FB_MONITOR_RENDER_EXTRA_MIRROR_SWAP: fb = g_pHyprOpenGL->m_renderData.pMonitor->m_mirrorSwapFB; break;
+ case FB_MONITOR_RENDER_EXTRA_OFF_MAIN: fb = g_pHyprOpenGL->m_renderData.pMonitor->m_offMainFB; break;
+ case FB_MONITOR_RENDER_EXTRA_MONITOR_MIRROR: fb = g_pHyprOpenGL->m_renderData.pMonitor->m_monitorMirrorFB; break;
+ case FB_MONITOR_RENDER_EXTRA_BLUR: fb = g_pHyprOpenGL->m_renderData.pMonitor->m_blurFB; break;
}
if (!fb) {
@@ -861,7 +870,7 @@ void CHyprRenderer::draw(CSurfacePassElement* element, const CRegion& damage) {
g_pHyprOpenGL->m_renderData.discardMode = m_data.discardMode;
g_pHyprOpenGL->m_renderData.discardOpacity = m_data.discardOpacity;
g_pHyprOpenGL->m_renderData.useNearestNeighbor = m_data.useNearestNeighbor;
- g_pHyprOpenGL->pushMonitorTransformEnabled(m_data.flipEndFrame);
+ pushMonitorTransformEnabled(m_data.flipEndFrame);
CScopeGuard x = {[]() {
g_pHyprOpenGL->m_renderData.primarySurfaceUVTopLeft = Vector2D(-1, -1);
@@ -872,7 +881,7 @@ void CHyprRenderer::draw(CSurfacePassElement* element, const CRegion& damage) {
g_pHyprOpenGL->m_renderData.discardMode = 0;
g_pHyprOpenGL->m_renderData.discardOpacity = 0;
g_pHyprOpenGL->m_renderData.useNearestNeighbor = false;
- g_pHyprOpenGL->popMonitorTransformEnabled();
+ g_pHyprRenderer->popMonitorTransformEnabled();
g_pHyprOpenGL->m_renderData.currentWindow.reset();
g_pHyprOpenGL->m_renderData.surface.reset();
g_pHyprOpenGL->m_renderData.currentLS.reset();
@@ -885,7 +894,7 @@ void CHyprRenderer::draw(CSurfacePassElement* element, const CRegion& damage) {
// this is bad, probably has been logged elsewhere. Means the texture failed
// uploading to the GPU.
- if (!TEXTURE->m_texID)
+ if (!TEXTURE->ok())
return;
const auto INTERACTIVERESIZEINPROGRESS = m_data.pWindow && g_layoutManager->dragController()->target() && g_layoutManager->dragController()->mode() == MBIND_RESIZE;
@@ -915,7 +924,7 @@ void CHyprRenderer::draw(CSurfacePassElement* element, const CRegion& damage) {
(!m_data.pWindow || (!m_data.pWindow->m_realSize->isBeingAnimated() && !INTERACTIVERESIZEINPROGRESS)) /* not window or not animated/resizing */ &&
(!m_data.pLS || (!m_data.pLS->m_realSize->isBeingAnimated())); /* not LS or not animated */
- g_pHyprRenderer->calculateUVForSurface(m_data.pWindow, m_data.surface, m_data.pMonitor->m_self.lock(), m_data.mainSurface, windowBox.size(), PROJSIZEUNSCALED, MISALIGNEDFSV1);
+ calculateUVForSurface(m_data.pWindow, m_data.surface, m_data.pMonitor->m_self.lock(), m_data.mainSurface, windowBox.size(), PROJSIZEUNSCALED, MISALIGNEDFSV1);
auto cancelRender = false;
g_pHyprOpenGL->m_renderData.clipRegion = element->visibleRegion(cancelRender);
@@ -999,11 +1008,11 @@ void CHyprRenderer::draw(CSurfacePassElement* element, const CRegion& damage) {
void CHyprRenderer::draw(CTexPassElement* element, const CRegion& damage) {
const auto& m_data = element->m_data;
- g_pHyprOpenGL->pushMonitorTransformEnabled(m_data.flipEndFrame);
+ pushMonitorTransformEnabled(m_data.flipEndFrame);
CScopeGuard x = {[&]() {
//
- g_pHyprOpenGL->popMonitorTransformEnabled();
+ g_pHyprRenderer->popMonitorTransformEnabled();
g_pHyprOpenGL->m_renderData.clipBox = {};
if (m_data.replaceProjection)
g_pHyprOpenGL->m_renderData.monitorProjection = g_pHyprOpenGL->m_renderData.pMonitor->m_projMatrix;
@@ -1042,15 +1051,29 @@ void CHyprRenderer::draw(CTexPassElement* element, const CRegion& damage) {
void CHyprRenderer::draw(CTextureMatteElement* element, const CRegion& damage) {
const auto& m_data = element->m_data;
if (m_data.disableTransformAndModify) {
- g_pHyprOpenGL->pushMonitorTransformEnabled(true);
+ pushMonitorTransformEnabled(true);
g_pHyprOpenGL->setRenderModifEnabled(false);
g_pHyprOpenGL->renderTextureMatte(m_data.tex, m_data.box, m_data.fb);
g_pHyprOpenGL->setRenderModifEnabled(true);
- g_pHyprOpenGL->popMonitorTransformEnabled();
+ popMonitorTransformEnabled();
} else
g_pHyprOpenGL->renderTextureMatte(m_data.tex, m_data.box, m_data.fb);
};
+void CHyprRenderer::pushMonitorTransformEnabled(bool enabled) {
+ m_monitorTransformStack.push(enabled);
+ m_monitorTransformEnabled = enabled;
+}
+
+void CHyprRenderer::popMonitorTransformEnabled() {
+ m_monitorTransformStack.pop();
+ m_monitorTransformEnabled = m_monitorTransformStack.top();
+}
+
+bool CHyprRenderer::monitorTransformEnabled() {
+ return m_monitorTransformEnabled;
+}
+
SP<ITexture> CHyprRenderer::createTexture(const SP<Aquamarine::IBuffer> buffer, bool keepDataCopy) {
if (!buffer)
return createTexture();
@@ -1271,7 +1294,7 @@ void CHyprRenderer::renderAllClientsForWorkspace(PHLMONITOR pMonitor, PHLWORKSPA
RENDERMODIFDATA.modifs.emplace_back(std::make_pair<>(SRenderModifData::eRenderModifType::RMOD_TYPE_SCALE, scale));
if UNLIKELY (!RENDERMODIFDATA.modifs.empty())
- g_pHyprRenderer->m_renderPass.add(makeUnique<CRendererHintsPassElement>(CRendererHintsPassElement::SData{RENDERMODIFDATA}));
+ m_renderPass.add(makeUnique<CRendererHintsPassElement>(CRendererHintsPassElement::SData{RENDERMODIFDATA}));
CScopeGuard x([&RENDERMODIFDATA] {
if (!RENDERMODIFDATA.modifs.empty()) {
@@ -1337,7 +1360,7 @@ void CHyprRenderer::renderAllClientsForWorkspace(PHLMONITOR pMonitor, PHLWORKSPA
data.box = {translate.x, translate.y, pMonitor->m_transformedSize.x * scale, pMonitor->m_transformedSize.y * scale};
data.color = CHyprColor(0, 0, 0, *PDIMSPECIAL * (ANIMOUT ? (1.0 - SPECIALANIMPROGRS) : SPECIALANIMPROGRS));
- g_pHyprRenderer->m_renderPass.add(makeUnique<CRectPassElement>(data));
+ m_renderPass.add(makeUnique<CRectPassElement>(data));
}
if (*PBLURSPECIAL && *PBLUR) {
@@ -1347,7 +1370,7 @@ void CHyprRenderer::renderAllClientsForWorkspace(PHLMONITOR pMonitor, PHLWORKSPA
data.blur = true;
data.blurA = (ANIMOUT ? (1.0 - SPECIALANIMPROGRS) : SPECIALANIMPROGRS);
- g_pHyprRenderer->m_renderPass.add(makeUnique<CRectPassElement>(data));
+ m_renderPass.add(makeUnique<CRectPassElement>(data));
}
}
@@ -1415,12 +1438,256 @@ void CHyprRenderer::renderBackground(PHLMONITOR pMonitor) {
g_pHyprOpenGL->clearWithTex(); // will apply the hypr "wallpaper"
}
+void CHyprRenderer::requestBackgroundResource() {
+ if (m_backgroundResource)
+ return;
+
+ static auto PNOWALLPAPER = CConfigValue<Hyprlang::INT>("misc:disable_hyprland_logo");
+ static auto PFORCEWALLPAPER = CConfigValue<Hyprlang::INT>("misc:force_default_wallpaper");
+
+ const auto FORCEWALLPAPER = std::clamp(*PFORCEWALLPAPER, sc<int64_t>(-1), sc<int64_t>(2));
+
+ if (*PNOWALLPAPER)
+ return;
+
+ static bool once = true;
+ static std::string texPath = "wall";
+
+ if (once) {
+ // get the adequate tex
+ if (FORCEWALLPAPER == -1) {
+ std::mt19937_64 engine(time(nullptr));
+ std::uniform_int_distribution<> distribution(0, 2);
+
+ texPath += std::to_string(distribution(engine));
+ } else
+ texPath += std::to_string(std::clamp(*PFORCEWALLPAPER, sc<int64_t>(0), sc<int64_t>(2)));
+
+ texPath += ".png";
+
+ texPath = resolveAssetPath(texPath);
+
+ once = false;
+ }
+
+ if (texPath.empty()) {
+ m_backgroundResourceFailed = true;
+ return;
+ }
+
+ m_backgroundResource = makeAtomicShared<Hyprgraphics::CImageResource>(texPath);
+
+ // doesn't have to be ASP as it's passed
+ SP<CMainLoopExecutor> executor = makeShared<CMainLoopExecutor>([this] {
+ for (const auto& m : g_pCompositor->m_monitors) {
+ damageMonitor(m);
+ }
+ });
+
+ m_backgroundResource->m_events.finished.listenStatic([executor] {
+ // this is in the worker thread.
+ executor->signal();
+ });
+
+ g_pAsyncResourceGatherer->enqueue(m_backgroundResource);
+}
+
+std::string CHyprRenderer::resolveAssetPath(const std::string& filename) {
+ std::string fullPath;
+ for (auto& e : ASSET_PATHS) {
+ std::string p = std::string{e} + "/hypr/" + filename;
+ std::error_code ec;
+ if (std::filesystem::exists(p, ec)) {
+ fullPath = p;
+ break;
+ } else
+ Log::logger->log(Log::DEBUG, "resolveAssetPath: looking at {} unsuccessful: ec {}", filename, ec.message());
+ }
+
+ if (fullPath.empty()) {
+ m_failedAssetsNo++;
+ Log::logger->log(Log::ERR, "resolveAssetPath: looking for {} failed (no provider found)", filename);
+ return "";
+ }
+
+ return fullPath;
+}
+
+SP<ITexture> CHyprRenderer::loadAsset(const std::string& filename) {
+
+ const std::string fullPath = resolveAssetPath(filename);
+
+ if (fullPath.empty())
+ return m_missingAssetTexture;
+
+ const auto CAIROSURFACE = cairo_image_surface_create_from_png(fullPath.c_str());
+
+ if (!CAIROSURFACE) {
+ m_failedAssetsNo++;
+ Log::logger->log(Log::ERR, "loadAsset: failed to load {} (corrupt / inaccessible / not png)", fullPath);
+ return m_missingAssetTexture;
+ }
+
+ auto tex = createTexture(CAIROSURFACE);
+
+ cairo_surface_destroy(CAIROSURFACE);
+
+ return tex;
+}
+
+bool CHyprRenderer::shouldUseNewBlurOptimizations(PHLLS pLayer, PHLWINDOW pWindow) {
+ static auto PBLURNEWOPTIMIZE = CConfigValue<Hyprlang::INT>("decoration:blur:new_optimizations");
+ static auto PBLURXRAY = CConfigValue<Hyprlang::INT>("decoration:blur:xray");
+
+ if (!g_pHyprOpenGL->m_renderData.pMonitor || !g_pHyprOpenGL->m_renderData.pMonitor->m_blurFB || !g_pHyprOpenGL->m_renderData.pMonitor->m_blurFB->getTexture())
+ return false;
+
+ if (pWindow && pWindow->m_ruleApplicator->xray().hasValue() && !pWindow->m_ruleApplicator->xray().valueOrDefault())
+ return false;
+
+ if (pLayer && pLayer->m_ruleApplicator->xray().valueOrDefault() == 0)
+ return false;
+
+ if ((*PBLURNEWOPTIMIZE && pWindow && !pWindow->m_isFloating && !pWindow->onSpecialWorkspace()) || *PBLURXRAY)
+ return true;
+
+ if ((pLayer && pLayer->m_ruleApplicator->xray().valueOrDefault() == 1) || (pWindow && pWindow->m_ruleApplicator->xray().valueOrDefault()))
+ return true;
+
+ return false;
+}
+
+void CHyprRenderer::initMissingAssetTexture() {
+
+ const auto CAIROSURFACE = cairo_image_surface_create(CAIRO_FORMAT_ARGB32, 512, 512);
+ const auto CAIRO = cairo_create(CAIROSURFACE);
+
+ cairo_set_antialias(CAIRO, CAIRO_ANTIALIAS_NONE);
+ cairo_save(CAIRO);
+ cairo_set_source_rgba(CAIRO, 0, 0, 0, 1);
+ cairo_set_operator(CAIRO, CAIRO_OPERATOR_SOURCE);
+ cairo_paint(CAIRO);
+ cairo_set_source_rgba(CAIRO, 1, 0, 1, 1);
+ cairo_rectangle(CAIRO, 256, 0, 256, 256);
+ cairo_fill(CAIRO);
+ cairo_rectangle(CAIRO, 0, 256, 256, 256);
+ cairo_fill(CAIRO);
+ cairo_restore(CAIRO);
+
+ cairo_surface_flush(CAIROSURFACE);
+
+ auto tex = createTexture(CAIROSURFACE);
+
+ cairo_surface_destroy(CAIROSURFACE);
+ cairo_destroy(CAIRO);
+
+ m_missingAssetTexture = tex;
+}
+
+void CHyprRenderer::initAssets() {
+ initMissingAssetTexture();
+
+ m_screencopyDeniedTexture = renderText("Permission denied to share screen", Colors::WHITE, 20);
+}
+
+SP<ITexture> CHyprRenderer::renderText(const std::string& text, CHyprColor col, int pt, bool italic, const std::string& fontFamily, int maxWidth, int weight) {
+ static auto FONT = CConfigValue<std::string>("misc:font_family");
+
+ const auto FONTFAMILY = fontFamily.empty() ? *FONT : fontFamily;
+ const auto FONTSIZE = pt;
+ const auto COLOR = col;
+
+ auto CAIROSURFACE = cairo_image_surface_create(CAIRO_FORMAT_ARGB32, 1920, 1080 /* arbitrary, just for size */);
+ auto CAIRO = cairo_create(CAIROSURFACE);
+
+ PangoLayout* layoutText = pango_cairo_create_layout(CAIRO);
+ PangoFontDescription* pangoFD = pango_font_description_new();
+
+ pango_font_description_set_family_static(pangoFD, FONTFAMILY.c_str());
+ pango_font_description_set_absolute_size(pangoFD, FONTSIZE * PANGO_SCALE);
+ pango_font_description_set_style(pangoFD, italic ? PANGO_STYLE_ITALIC : PANGO_STYLE_NORMAL);
+ pango_font_description_set_weight(pangoFD, sc<PangoWeight>(weight));
+ pango_layout_set_font_description(layoutText, pangoFD);
+
+ cairo_set_source_rgba(CAIRO, COLOR.r, COLOR.g, COLOR.b, COLOR.a);
+
+ int textW = 0, textH = 0;
+ pango_layout_set_text(layoutText, text.c_str(), -1);
+
+ if (maxWidth > 0) {
+ pango_layout_set_width(layoutText, maxWidth * PANGO_SCALE);
+ pango_layout_set_ellipsize(layoutText, PANGO_ELLIPSIZE_END);
+ }
+
+ pango_layout_get_size(layoutText, &textW, &textH);
+ textW /= PANGO_SCALE;
+ textH /= PANGO_SCALE;
+
+ pango_font_description_free(pangoFD);
+ g_object_unref(layoutText);
+ cairo_destroy(CAIRO);
+ cairo_surface_destroy(CAIROSURFACE);
+
+ CAIROSURFACE = cairo_image_surface_create(CAIRO_FORMAT_ARGB32, textW, textH);
+ CAIRO = cairo_create(CAIROSURFACE);
+
+ layoutText = pango_cairo_create_layout(CAIRO);
+ pangoFD = pango_font_description_new();
+
+ pango_font_description_set_family_static(pangoFD, FONTFAMILY.c_str());
+ pango_font_description_set_absolute_size(pangoFD, FONTSIZE * PANGO_SCALE);
+ pango_font_description_set_style(pangoFD, italic ? PANGO_STYLE_ITALIC : PANGO_STYLE_NORMAL);
+ pango_font_description_set_weight(pangoFD, sc<PangoWeight>(weight));
+ pango_layout_set_font_description(layoutText, pangoFD);
+ pango_layout_set_text(layoutText, text.c_str(), -1);
+
+ cairo_set_source_rgba(CAIRO, COLOR.r, COLOR.g, COLOR.b, COLOR.a);
+
+ cairo_move_to(CAIRO, 0, 0);
+ pango_cairo_show_layout(CAIRO, layoutText);
+
+ pango_font_description_free(pangoFD);
+ g_object_unref(layoutText);
+
+ cairo_surface_flush(CAIROSURFACE);
+
+ auto tex = createTexture(cairo_image_surface_get_width(CAIROSURFACE), cairo_image_surface_get_height(CAIROSURFACE), cairo_image_surface_get_data(CAIROSURFACE));
+
+ cairo_destroy(CAIRO);
+ cairo_surface_destroy(CAIROSURFACE);
+
+ return tex;
+}
+
+void CHyprRenderer::ensureLockTexturesRendered(bool load) {
+ static bool loaded = false;
+
+ if (loaded == load)
+ return;
+
+ loaded = load;
+
+ if (load) {
+ // this will cause a small hitch. I don't think we can do much, other than wasting VRAM and having this loaded all the time.
+ m_lockDeadTexture = loadAsset("lockdead.png");
+ m_lockDead2Texture = loadAsset("lockdead2.png");
+
+ const auto VT = g_pCompositor->getVTNr();
+
+ m_lockTtyTextTexture = renderText(std::format("Running on tty {}", VT.has_value() ? std::to_string(*VT) : "unknown"), CHyprColor{0.9F, 0.9F, 0.9F, 0.7F}, 20, true);
+ } else {
+ m_lockDeadTexture.reset();
+ m_lockDead2Texture.reset();
+ m_lockTtyTextTexture.reset();
+ }
+}
+
void CHyprRenderer::renderLockscreen(PHLMONITOR pMonitor, const Time::steady_tp& now, const CBox& geometry) {
TRACY_GPU_ZONE("RenderLockscreen");
const bool LOCKED = g_pSessionLockManager->isSessionLocked();
if (!LOCKED) {
- g_pHyprOpenGL->ensureLockTexturesRendered(false);
+ ensureLockTexturesRendered(false);
return;
}
@@ -1431,7 +1698,7 @@ void CHyprRenderer::renderLockscreen(PHLMONITOR pMonitor, const Time::steady_tp&
const auto PSLS = g_pSessionLockManager->getSessionLockSurfaceForMonitor(pMonitor->m_id);
const bool RENDERLOCKMISSING = (PSLS.expired() || g_pSessionLockManager->clientDenied()) && g_pSessionLockManager->shallConsiderLockMissing();
- g_pHyprOpenGL->ensureLockTexturesRendered(RENDERLOCKMISSING);
+ ensureLockTexturesRendered(RENDERLOCKMISSING);
if (RENDERLOCKMISSING)
renderSessionLockMissing(pMonitor);
@@ -1462,7 +1729,7 @@ void CHyprRenderer::renderSessionLockPrimer(PHLMONITOR pMonitor) {
data.color = CHyprColor(0, 0, 0, 1.f);
data.box = CBox{{}, pMonitor->m_pixelSize};
- m_renderPass.add(makeUnique<CRectPassElement>(std::move(data)));
+ m_renderPass.add(makeUnique<CRectPassElement>(data));
}
void CHyprRenderer::renderSessionLockMissing(PHLMONITOR pMonitor) {
@@ -1472,16 +1739,16 @@ void CHyprRenderer::renderSessionLockMissing(PHLMONITOR pMonitor) {
// else: render image, with instructions. Lock is gone.
CBox monbox = {{}, pMonitor->m_pixelSize};
CTexPassElement::SRenderData data;
- data.tex = (ANY_PRESENT) ? g_pHyprOpenGL->m_lockDead2Texture : g_pHyprOpenGL->m_lockDeadTexture;
+ data.tex = (ANY_PRESENT) ? m_lockDead2Texture : m_lockDeadTexture;
data.box = monbox;
data.a = 1;
m_renderPass.add(makeUnique<CTexPassElement>(data));
- if (!ANY_PRESENT && g_pHyprOpenGL->m_lockTtyTextTexture) {
+ if (!ANY_PRESENT && m_lockTtyTextTexture) {
// also render text for the tty number
- CBox texbox = {{}, g_pHyprOpenGL->m_lockTtyTextTexture->m_size};
- data.tex = g_pHyprOpenGL->m_lockTtyTextTexture;
+ CBox texbox = {{}, m_lockTtyTextTexture->m_size};
+ data.tex = m_lockTtyTextTexture;
data.box = texbox;
m_renderPass.add(makeUnique<CTexPassElement>(std::move(data)));
@@ -2654,7 +2921,7 @@ void CHyprRenderer::initiateManualCrash() {
m_crashingInProgress = true;
m_crashingDistort = 0.5;
- g_pHyprOpenGL->m_globalTimer.reset();
+ m_globalTimer.reset();
static auto PDT = rc<Hyprlang::INT* const*>(g_pConfigManager->getConfigValuePtr("debug:damage_tracking"));
@@ -2667,7 +2934,7 @@ SP<IRenderbuffer> CHyprRenderer::getOrCreateRenderbuffer(SP<Aquamarine::IBuffer>
if (it != m_renderbuffers.end())
return *it;
- auto buf = makeShared<CGLRenderbuffer>(buffer, fmt);
+ auto buf = getOrCreateRenderbufferInternal(buffer, fmt);
if (!buf->good())
return nullptr;
@@ -2676,24 +2943,9 @@ SP<IRenderbuffer> CHyprRenderer::getOrCreateRenderbuffer(SP<Aquamarine::IBuffer>
return buf;
}
-void CHyprRenderer::makeEGLCurrent() {
- if (!g_pCompositor || !g_pHyprOpenGL)
- return;
-
- if (eglGetCurrentContext() != g_pHyprOpenGL->m_eglContext)
- eglMakeCurrent(g_pHyprOpenGL->m_eglDisplay, EGL_NO_SURFACE, EGL_NO_SURFACE, g_pHyprOpenGL->m_eglContext);
-}
-
-void CHyprRenderer::unsetEGL() {
- if (!g_pHyprOpenGL)
- return;
-
- eglMakeCurrent(g_pHyprOpenGL->m_eglDisplay, EGL_NO_SURFACE, EGL_NO_SURFACE, EGL_NO_CONTEXT);
-}
-
bool CHyprRenderer::beginRender(PHLMONITOR pMonitor, CRegion& damage, eRenderMode mode, SP<IHLBuffer> buffer, SP<IFramebuffer> fb, bool simple) {
- makeEGLCurrent();
+ g_pHyprOpenGL->makeEGLCurrent();
m_renderPass.clear();
@@ -2823,7 +3075,7 @@ void CHyprRenderer::endRender(const std::function<void()>& renderingDoneCallback
}
}
-void CHyprRenderer::onRenderbufferDestroy(CGLRenderbuffer* rb) {
+void CHyprRenderer::onRenderbufferDestroy(IRenderbuffer* rb) {
std::erase_if(m_renderbuffers, [&](const auto& rbo) { return rbo.get() == rb; });
}
@@ -2878,12 +3130,10 @@ void CHyprRenderer::makeSnapshot(PHLWINDOW pWindow) {
PHLWINDOWREF ref{pWindow};
- makeEGLCurrent();
-
- if (!g_pHyprOpenGL->m_windowFramebuffers.contains(ref))
- g_pHyprOpenGL->m_windowFramebuffers[ref] = g_pHyprRenderer->createFB();
+ if (!ref->m_snapshotFB)
+ ref->m_snapshotFB = createFB("window snapshot");
- const auto PFRAMEBUFFER = g_pHyprOpenGL->m_windowFramebuffers[ref];
+ const auto PFRAMEBUFFER = ref->m_snapshotFB;
PFRAMEBUFFER->alloc(PMONITOR->m_pixelSize.x, PMONITOR->m_pixelSize.y, DRM_FORMAT_ABGR8888);
@@ -2907,19 +3157,17 @@ void CHyprRenderer::makeSnapshot(PHLLS pLayer) {
if (!PMONITOR || !PMONITOR->m_output || PMONITOR->m_pixelSize.x <= 0 || PMONITOR->m_pixelSize.y <= 0)
return;
- Log::logger->log(Log::DEBUG, "renderer: making a snapshot of {:x}", rc<uintptr_t>(pLayer.get()));
+ Log::logger->log(Log::DEBUG, "renderer: making a snapshot of layer {:x}", rc<uintptr_t>(pLayer.get()));
// we need to "damage" the entire monitor
// so that we render the entire window
// this is temporary, doesn't mess with the actual damage
CRegion fakeDamage{0, 0, sc<int>(PMONITOR->m_transformedSize.x), sc<int>(PMONITOR->m_transformedSize.y)};
- makeEGLCurrent();
+ if (!pLayer->m_snapshotFB)
+ pLayer->m_snapshotFB = createFB("layer snapshot");
- if (!g_pHyprOpenGL->m_layerFramebuffers.contains(pLayer))
- g_pHyprOpenGL->m_layerFramebuffers[pLayer] = g_pHyprRenderer->createFB();
-
- const auto PFRAMEBUFFER = g_pHyprOpenGL->m_layerFramebuffers[pLayer];
+ const auto PFRAMEBUFFER = pLayer->m_snapshotFB;
PFRAMEBUFFER->alloc(PMONITOR->m_pixelSize.x, PMONITOR->m_pixelSize.y, DRM_FORMAT_ABGR8888);
@@ -2951,12 +3199,10 @@ void CHyprRenderer::makeSnapshot(WP<Desktop::View::CPopup> popup) {
CRegion fakeDamage{0, 0, PMONITOR->m_transformedSize.x, PMONITOR->m_transformedSize.y};
- makeEGLCurrent();
-
- if (!g_pHyprOpenGL->m_popupFramebuffers.contains(popup))
- g_pHyprOpenGL->m_popupFramebuffers[popup] = g_pHyprRenderer->createFB();
+ if (!popup->m_snapshotFB)
+ popup->m_snapshotFB = createFB("popup shapshot");
- const auto PFRAMEBUFFER = g_pHyprOpenGL->m_popupFramebuffers[popup];
+ const auto PFRAMEBUFFER = popup->m_snapshotFB;
PFRAMEBUFFER->alloc(PMONITOR->m_pixelSize.x, PMONITOR->m_pixelSize.y, DRM_FORMAT_ABGR8888);
@@ -3002,10 +3248,10 @@ void CHyprRenderer::renderSnapshot(PHLWINDOW pWindow) {
PHLWINDOWREF ref{pWindow};
- if (!g_pHyprOpenGL->m_windowFramebuffers.contains(ref))
+ if (!ref->m_snapshotFB)
return;
- const auto FBDATA = g_pHyprOpenGL->m_windowFramebuffers.at(ref);
+ const auto FBDATA = ref->m_snapshotFB;
if (!FBDATA->getTexture())
return;
@@ -3058,10 +3304,10 @@ void CHyprRenderer::renderSnapshot(PHLWINDOW pWindow) {
}
void CHyprRenderer::renderSnapshot(PHLLS pLayer) {
- if (!g_pHyprOpenGL->m_layerFramebuffers.contains(pLayer))
+ if (!pLayer->m_snapshotFB)
return;
- const auto FBDATA = g_pHyprOpenGL->m_layerFramebuffers.at(pLayer);
+ const auto FBDATA = pLayer->m_snapshotFB;
if (!FBDATA->getTexture())
return;
@@ -3100,12 +3346,12 @@ void CHyprRenderer::renderSnapshot(PHLLS pLayer) {
}
void CHyprRenderer::renderSnapshot(WP<Desktop::View::CPopup> popup) {
- if (!g_pHyprOpenGL->m_popupFramebuffers.contains(popup))
+ if (!popup->m_snapshotFB)
return;
static CConfigValue PBLURIGNOREA = CConfigValue<Hyprlang::FLOAT>("decoration:blur:popups_ignorealpha");
- const auto FBDATA = g_pHyprOpenGL->m_popupFramebuffers.at(popup);
+ const auto FBDATA = popup->m_snapshotFB;
if (!FBDATA->getTexture())
return;
@@ -3173,7 +3419,7 @@ bool CHyprRenderer::reloadShaders(const std::string& path) {
}
SP<ITexture> CHyprRenderer::createStencilTexture(const int width, const int height) {
- makeEGLCurrent();
+ g_pHyprOpenGL->makeEGLCurrent();
auto tex = makeShared<CGLTexture>();
tex->allocate({width, height});
@@ -3181,17 +3427,17 @@ SP<ITexture> CHyprRenderer::createStencilTexture(const int width, const int heig
}
SP<ITexture> CHyprRenderer::createTexture(bool opaque) {
- makeEGLCurrent();
+ g_pHyprOpenGL->makeEGLCurrent();
return makeShared<CGLTexture>(opaque);
}
SP<ITexture> CHyprRenderer::createTexture(uint32_t drmFormat, uint8_t* pixels, uint32_t stride, const Vector2D& size, bool keepDataCopy, bool opaque) {
- makeEGLCurrent();
+ g_pHyprOpenGL->makeEGLCurrent();
return makeShared<CGLTexture>(drmFormat, pixels, stride, size, keepDataCopy, opaque);
}
SP<ITexture> CHyprRenderer::createTexture(const Aquamarine::SDMABUFAttrs& attrs, bool opaque) {
- makeEGLCurrent();
+ g_pHyprOpenGL->makeEGLCurrent();
const auto image = g_pHyprOpenGL->createEGLImage(attrs);
if (!image)
return nullptr;
@@ -3199,7 +3445,7 @@ SP<ITexture> CHyprRenderer::createTexture(const Aquamarine::SDMABUFAttrs& attrs,
}
SP<ITexture> CHyprRenderer::createTexture(const int width, const int height, unsigned char* const data) {
- makeEGLCurrent();
+ g_pHyprOpenGL->makeEGLCurrent();
SP<ITexture> tex = makeShared<CGLTexture>();
tex->allocate({width, height});
@@ -3222,7 +3468,7 @@ SP<ITexture> CHyprRenderer::createTexture(const int width, const int height, uns
}
SP<ITexture> CHyprRenderer::createTexture(cairo_surface_t* cairo) {
- makeEGLCurrent();
+ g_pHyprOpenGL->makeEGLCurrent();
const auto CAIROFORMAT = cairo_image_surface_get_format(cairo);
auto tex = makeShared<CGLTexture>();
@@ -3248,11 +3494,28 @@ SP<ITexture> CHyprRenderer::createTexture(cairo_surface_t* cairo) {
}
SP<ITexture> CHyprRenderer::createTexture(std::span<const float> lut3D, size_t N) {
- makeEGLCurrent();
+ g_pHyprOpenGL->makeEGLCurrent();
return makeShared<CGLTexture>(lut3D, N);
}
SP<IFramebuffer> CHyprRenderer::createFB(const std::string& name) {
- makeEGLCurrent();
+ g_pHyprOpenGL->makeEGLCurrent();
return makeShared<CGLFramebuffer>(name);
+}
+
+bool CHyprRenderer::explicitSyncSupported() {
+ return g_pHyprOpenGL->explicitSyncSupported();
+}
+
+std::vector<SDRMFormat> CHyprRenderer::getDRMFormats() {
+ return g_pHyprOpenGL->getDRMFormats();
+}
+
+std::vector<uint64_t> CHyprRenderer::getDRMFormatModifiers(DRMFormat format) {
+ return g_pHyprOpenGL->getDRMFormatModifiers(format);
+}
+
+SP<IRenderbuffer> CHyprRenderer::getOrCreateRenderbufferInternal(SP<Aquamarine::IBuffer> buffer, uint32_t fmt) {
+ g_pHyprOpenGL->makeEGLCurrent();
+ return makeShared<CGLRenderbuffer>(buffer, fmt);
} \ No newline at end of file
diff --git a/src/render/Renderer.hpp b/src/render/Renderer.hpp
index b854715d..53ca9f12 100644
--- a/src/render/Renderer.hpp
+++ b/src/render/Renderer.hpp
@@ -101,34 +101,35 @@ class CHyprRenderer {
CHyprRenderer();
~CHyprRenderer();
- void renderMonitor(PHLMONITOR pMonitor, bool commit = true);
- void arrangeLayersForMonitor(const MONITORID&);
- void damageSurface(SP<CWLSurfaceResource>, double, double, double scale = 1.0);
- void damageWindow(PHLWINDOW, bool forceFull = false);
- void damageBox(const CBox&, bool skipFrameSchedule = false);
- void damageBox(const int& x, const int& y, const int& w, const int& h);
- void damageRegion(const CRegion&);
- void damageMonitor(PHLMONITOR);
- void damageMirrorsWith(PHLMONITOR, const CRegion&);
- bool shouldRenderWindow(PHLWINDOW, PHLMONITOR);
- bool shouldRenderWindow(PHLWINDOW);
- void ensureCursorRenderingMode();
- bool shouldRenderCursor();
- void setCursorHidden(bool hide);
+ WP<CHyprOpenGLImpl> glBackend();
+
+ void renderMonitor(PHLMONITOR pMonitor, bool commit = true);
+ void arrangeLayersForMonitor(const MONITORID&);
+ void damageSurface(SP<CWLSurfaceResource>, double, double, double scale = 1.0);
+ void damageWindow(PHLWINDOW, bool forceFull = false);
+ void damageBox(const CBox&, bool skipFrameSchedule = false);
+ void damageBox(const int& x, const int& y, const int& w, const int& h);
+ void damageRegion(const CRegion&);
+ void damageMonitor(PHLMONITOR);
+ void damageMirrorsWith(PHLMONITOR, const CRegion&);
+ bool shouldRenderWindow(PHLWINDOW, PHLMONITOR);
+ bool shouldRenderWindow(PHLWINDOW);
+ void ensureCursorRenderingMode();
+ bool shouldRenderCursor();
+ void setCursorHidden(bool hide);
void calculateUVForSurface(PHLWINDOW, SP<CWLSurfaceResource>, PHLMONITOR pMonitor, bool main = false, const Vector2D& projSize = {}, const Vector2D& projSizeUnscaled = {},
bool fixMisalignedFSV1 = false);
std::tuple<float, float, float> getRenderTimes(PHLMONITOR pMonitor); // avg max min
+ void ensureLockTexturesRendered(bool load);
void renderLockscreen(PHLMONITOR pMonitor, const Time::steady_tp& now, const CBox& geometry);
void setCursorSurface(SP<Desktop::View::CWLSurface> surf, int hotspotX, int hotspotY, bool force = false);
void setCursorFromName(const std::string& name, bool force = false);
- void onRenderbufferDestroy(CGLRenderbuffer* rb);
+ void onRenderbufferDestroy(IRenderbuffer* rb);
SP<IRenderbuffer> getCurrentRBO();
bool isNvidia();
bool isIntel();
bool isSoftware();
bool isMgpu();
- void makeEGLCurrent();
- void unsetEGL();
void addWindowToRenderUnfocused(PHLWINDOW window);
void makeSnapshot(PHLWINDOW);
void makeSnapshot(PHLLS);
@@ -170,33 +171,54 @@ class CHyprRenderer {
std::string name;
} m_lastCursorData;
- CRenderPass m_renderPass = {};
-
- SP<ITexture> createStencilTexture(const int width, const int height);
- SP<ITexture> createTexture(bool opaque = false);
- SP<ITexture> createTexture(uint32_t drmFormat, uint8_t* pixels, uint32_t stride, const Vector2D& size, bool keepDataCopy = false, bool opaque = false);
- SP<ITexture> createTexture(const Aquamarine::SDMABUFAttrs&, bool opaque = false);
- SP<ITexture> createTexture(const int width, const int height, unsigned char* const);
- SP<ITexture> createTexture(cairo_surface_t* cairo);
- SP<ITexture> createTexture(const SP<Aquamarine::IBuffer> buffer, bool keepDataCopy = false);
- SP<ITexture> createTexture(std::span<const float> lut3D, size_t N);
- SP<IFramebuffer> createFB(const std::string& name = "");
-
- SCMSettings getCMSettings(const NColorManagement::PImageDescription imageDescription, const NColorManagement::PImageDescription targetImageDescription,
- SP<CWLSurfaceResource> surface = nullptr, bool modifySDR = false, float sdrMinLuminance = -1.0f, int sdrMaxLuminance = -1);
- bool reloadShaders(const std::string& path = "");
-
- void draw(CBorderPassElement* element, const CRegion& damage);
- void draw(CClearPassElement* element, const CRegion& damage);
- void draw(CFramebufferElement* element, const CRegion& damage);
- void draw(CPreBlurElement* element, const CRegion& damage);
- void draw(CRectPassElement* element, const CRegion& damage);
- void draw(CRendererHintsPassElement* element, const CRegion& damage);
- void draw(CShadowPassElement* element, const CRegion& damage);
- void draw(CSurfacePassElement* element, const CRegion& damage);
- void draw(CTexPassElement* element, const CRegion& damage);
- void draw(CTextureMatteElement* element, const CRegion& damage);
- void draw(WP<IPassElement> element, const CRegion& damage);
+ CRenderPass m_renderPass = {};
+
+ SP<IRenderbuffer> getOrCreateRenderbuffer(SP<Aquamarine::IBuffer> buffer, uint32_t fmt); // TODO? move to protected and fix CPointerManager::renderHWCursorBuffer
+ SP<ITexture> m_screencopyDeniedTexture; // TODO? make readonly
+ uint m_failedAssetsNo = 0; // TODO? make readonly
+ bool m_reloadScreenShader = true; // at launch it can be set
+ CTimer m_globalTimer;
+
+ SP<ITexture> createStencilTexture(const int width, const int height);
+ SP<ITexture> createTexture(bool opaque = false);
+ SP<ITexture> createTexture(uint32_t drmFormat, uint8_t* pixels, uint32_t stride, const Vector2D& size, bool keepDataCopy = false, bool opaque = false);
+ SP<ITexture> createTexture(const Aquamarine::SDMABUFAttrs&, bool opaque = false);
+ SP<ITexture> createTexture(const int width, const int height, unsigned char* const);
+ SP<ITexture> createTexture(cairo_surface_t* cairo);
+ SP<ITexture> createTexture(const SP<Aquamarine::IBuffer> buffer, bool keepDataCopy = false);
+ SP<ITexture> createTexture(std::span<const float> lut3D, size_t N);
+ SP<ITexture> renderText(const std::string& text, CHyprColor col, int pt, bool italic = false, const std::string& fontFamily = "", int maxWidth = 0, int weight = 400);
+ SP<ITexture> loadAsset(const std::string& filename);
+ bool shouldUseNewBlurOptimizations(PHLLS pLayer, PHLWINDOW pWindow);
+ bool explicitSyncSupported();
+ std::vector<SDRMFormat> getDRMFormats();
+ std::vector<uint64_t> getDRMFormatModifiers(DRMFormat format);
+ SP<IFramebuffer> createFB(const std::string& name = "");
+ void pushMonitorTransformEnabled(bool enabled);
+ void popMonitorTransformEnabled();
+ bool monitorTransformEnabled();
+
+ SCMSettings getCMSettings(const NColorManagement::PImageDescription imageDescription, const NColorManagement::PImageDescription targetImageDescription,
+ SP<CWLSurfaceResource> surface = nullptr, bool modifySDR = false, float sdrMinLuminance = -1.0f, int sdrMaxLuminance = -1);
+ bool reloadShaders(const std::string& path = "");
+
+ void draw(CBorderPassElement* element, const CRegion& damage);
+ void draw(CClearPassElement* element, const CRegion& damage);
+ void draw(CFramebufferElement* element, const CRegion& damage);
+ void draw(CPreBlurElement* element, const CRegion& damage);
+ void draw(CRectPassElement* element, const CRegion& damage);
+ void draw(CRendererHintsPassElement* element, const CRegion& damage);
+ void draw(CShadowPassElement* element, const CRegion& damage);
+ void draw(CSurfacePassElement* element, const CRegion& damage);
+ void draw(CTexPassElement* element, const CRegion& damage);
+ void draw(CTextureMatteElement* element, const CRegion& damage);
+ void draw(WP<IPassElement> element, const CRegion& damage);
+
+ SP<ITexture> m_lockDeadTexture;
+ SP<ITexture> m_lockDead2Texture;
+ SP<ITexture> m_lockTtyTextTexture;
+ bool m_monitorTransformEnabled = false; // do not modify directly
+ std::stack<bool> m_monitorTransformStack;
private:
void arrangeLayerArray(PHLMONITOR, const std::vector<PHLLSREF>&, bool, CBox*);
@@ -216,20 +238,30 @@ class CHyprRenderer {
bool commitPendingAndDoExplicitSync(PHLMONITOR pMonitor);
- bool shouldBlur(PHLLS ls);
- bool shouldBlur(PHLWINDOW w);
- bool shouldBlur(WP<Desktop::View::CPopup> p);
-
- bool m_cursorHidden = false;
- bool m_cursorHiddenByCondition = false;
- bool m_cursorHasSurface = false;
- SP<IRenderbuffer> m_currentRenderbuffer = nullptr;
- SP<Aquamarine::IBuffer> m_currentBuffer = nullptr;
- eRenderMode m_renderMode = RENDER_MODE_NORMAL;
- bool m_nvidia = false;
- bool m_intel = false;
- bool m_software = false;
- bool m_mgpu = false;
+ void requestBackgroundResource();
+ //
+ SP<IRenderbuffer> getOrCreateRenderbufferInternal(SP<Aquamarine::IBuffer> buffer, uint32_t fmt);
+ std::string resolveAssetPath(const std::string& file);
+ void initMissingAssetTexture();
+ void initAssets();
+ SP<ITexture> m_missingAssetTexture;
+ ASP<Hyprgraphics::CImageResource> m_backgroundResource;
+ bool m_backgroundResourceFailed = false;
+
+ bool shouldBlur(PHLLS ls);
+ bool shouldBlur(PHLWINDOW w);
+ bool shouldBlur(WP<Desktop::View::CPopup> p);
+
+ bool m_cursorHidden = false;
+ bool m_cursorHiddenByCondition = false;
+ bool m_cursorHasSurface = false;
+ SP<IRenderbuffer> m_currentRenderbuffer = nullptr;
+ SP<Aquamarine::IBuffer> m_currentBuffer = nullptr;
+ eRenderMode m_renderMode = RENDER_MODE_NORMAL;
+ bool m_nvidia = false;
+ bool m_intel = false;
+ bool m_software = false;
+ bool m_mgpu = false;
struct {
bool hiddenOnTouch = false;
@@ -238,7 +270,6 @@ class CHyprRenderer {
bool hiddenOnKeyboard = false;
} m_cursorHiddenConditions;
- SP<IRenderbuffer> getOrCreateRenderbuffer(SP<Aquamarine::IBuffer> buffer, uint32_t fmt);
std::vector<SP<IRenderbuffer>> m_renderbuffers;
std::vector<PHLWINDOWREF> m_renderUnfocused;
SP<CEventLoopTimer> m_renderUnfocusedTimer;
diff --git a/src/render/decorations/CHyprDropShadowDecoration.cpp b/src/render/decorations/CHyprDropShadowDecoration.cpp
index 5e1b6e8a..1042cd1f 100644
--- a/src/render/decorations/CHyprDropShadowDecoration.cpp
+++ b/src/render/decorations/CHyprDropShadowDecoration.cpp
@@ -155,8 +155,8 @@ void CHyprDropShadowDecoration::render(PHLMONITOR pMonitor, float const& a) {
g_pHyprOpenGL->m_renderData.currentWindow = m_window;
// we'll take the liberty of using this as it should not be used rn
- auto alphaFB = g_pHyprOpenGL->m_renderData.pCurrentMonData->mirrorFB;
- auto alphaSwapFB = g_pHyprOpenGL->m_renderData.pCurrentMonData->mirrorSwapFB;
+ auto alphaFB = g_pHyprOpenGL->m_renderData.pMonitor->m_mirrorFB;
+ auto alphaSwapFB = g_pHyprOpenGL->m_renderData.pMonitor->m_mirrorSwapFB;
auto LASTFB = g_pHyprOpenGL->m_renderData.currentFB;
fullBox.scale(pMonitor->m_scale).round();
@@ -211,11 +211,11 @@ void CHyprDropShadowDecoration::render(PHLMONITOR pMonitor, float const& a) {
CBox monbox = {0, 0, pMonitor->m_transformedSize.x, pMonitor->m_transformedSize.y};
- g_pHyprOpenGL->pushMonitorTransformEnabled(true);
+ g_pHyprRenderer->pushMonitorTransformEnabled(true);
g_pHyprOpenGL->setRenderModifEnabled(false);
g_pHyprOpenGL->renderTextureMatte(alphaSwapFB->getTexture(), monbox, alphaFB);
g_pHyprOpenGL->setRenderModifEnabled(true);
- g_pHyprOpenGL->popMonitorTransformEnabled();
+ g_pHyprRenderer->popMonitorTransformEnabled();
g_pHyprOpenGL->m_renderData.damage = saveDamage;
} else
diff --git a/src/render/decorations/CHyprGroupBarDecoration.cpp b/src/render/decorations/CHyprGroupBarDecoration.cpp
index 6ce69261..c11da56c 100644
--- a/src/render/decorations/CHyprGroupBarDecoration.cpp
+++ b/src/render/decorations/CHyprGroupBarDecoration.cpp
@@ -308,7 +308,7 @@ CTitleTex::CTitleTex(PHLWINDOW pWindow, const Vector2D& bufferSize, const float
const auto FONTFAMILY = *PTITLEFONTFAMILY != STRVAL_EMPTY ? *PTITLEFONTFAMILY : *FALLBACKFONT;
-#define RENDER_TEXT(color, weight) g_pHyprOpenGL->renderText(pWindow->m_title, (color), *PTITLEFONTSIZE* monitorScale, false, FONTFAMILY, bufferSize.x - 2, (weight));
+#define RENDER_TEXT(color, weight) g_pHyprRenderer->renderText(pWindow->m_title, (color), *PTITLEFONTSIZE* monitorScale, false, FONTFAMILY, bufferSize.x - 2, (weight));
m_texActive = RENDER_TEXT(COLORACTIVE, FONTWEIGHTACTIVE->m_value);
m_texInactive = RENDER_TEXT(COLORINACTIVE, FONTWEIGHTINACTIVE->m_value);
m_texLockedActive = RENDER_TEXT(COLORLOCKEDACTIVE, FONTWEIGHTACTIVE->m_value);
diff --git a/src/render/gl/GLFramebuffer.cpp b/src/render/gl/GLFramebuffer.cpp
index d821f766..39bfba7f 100644
--- a/src/render/gl/GLFramebuffer.cpp
+++ b/src/render/gl/GLFramebuffer.cpp
@@ -8,7 +8,7 @@ CGLFramebuffer::CGLFramebuffer() : IFramebuffer() {}
CGLFramebuffer::CGLFramebuffer(const std::string& name) : IFramebuffer(name) {}
bool CGLFramebuffer::internalAlloc(int w, int h, uint32_t drmFormat) {
- g_pHyprRenderer->makeEGLCurrent();
+ g_pHyprOpenGL->makeEGLCurrent();
bool firstAlloc = false;
@@ -108,7 +108,7 @@ bool CGLFramebuffer::readPixels(CHLBufferReference buffer, uint32_t offsetX, uin
return false;
}
- g_pHyprRenderer->makeEGLCurrent();
+ g_pHyprOpenGL->makeEGLCurrent();
glBindFramebuffer(GL_READ_FRAMEBUFFER, getFBID());
bind();
diff --git a/src/render/gl/GLRenderbuffer.cpp b/src/render/gl/GLRenderbuffer.cpp
index 8299d0e4..494a81d9 100644
--- a/src/render/gl/GLRenderbuffer.cpp
+++ b/src/render/gl/GLRenderbuffer.cpp
@@ -15,7 +15,7 @@ CGLRenderbuffer::~CGLRenderbuffer() {
if (!g_pCompositor || g_pCompositor->m_isShuttingDown || !g_pHyprRenderer)
return;
- g_pHyprRenderer->makeEGLCurrent();
+ g_pHyprOpenGL->makeEGLCurrent();
unbind();
m_framebuffer->release();
@@ -62,7 +62,7 @@ CGLRenderbuffer::CGLRenderbuffer(SP<Aquamarine::IBuffer> buffer, uint32_t format
}
void CGLRenderbuffer::bind() {
- g_pHyprRenderer->makeEGLCurrent();
+ g_pHyprOpenGL->makeEGLCurrent();
m_framebuffer->bind();
}
diff --git a/src/render/gl/GLTexture.cpp b/src/render/gl/GLTexture.cpp
index 6a1fb172..9c7ddc35 100644
--- a/src/render/gl/GLTexture.cpp
+++ b/src/render/gl/GLTexture.cpp
@@ -13,7 +13,7 @@ CGLTexture::~CGLTexture() {
if (!g_pCompositor || g_pCompositor->m_isShuttingDown || !g_pHyprRenderer)
return;
- g_pHyprRenderer->makeEGLCurrent();
+ g_pHyprOpenGL->makeEGLCurrent();
if (m_texID) {
GLCALL(glDeleteTextures(1, &m_texID));
m_texID = 0;
@@ -28,7 +28,7 @@ CGLTexture::~CGLTexture() {
CGLTexture::CGLTexture(uint32_t drmFormat, uint8_t* pixels, uint32_t stride, const Vector2D& size_, bool keepDataCopy, bool opaque) :
ITexture(drmFormat, pixels, stride, size_, keepDataCopy, opaque) {
- g_pHyprRenderer->makeEGLCurrent();
+ g_pHyprOpenGL->makeEGLCurrent();
const auto format = NFormatUtils::getPixelFormatFromDRM(drmFormat);
ASSERT(format);
@@ -120,7 +120,7 @@ void CGLTexture::update(uint32_t drmFormat, uint8_t* pixels, uint32_t stride, co
if (damage.empty())
return;
- g_pHyprRenderer->makeEGLCurrent();
+ g_pHyprOpenGL->makeEGLCurrent();
const auto format = NFormatUtils::getPixelFormatFromDRM(drmFormat);
ASSERT(format);
diff --git a/src/render/pass/Pass.cpp b/src/render/pass/Pass.cpp
index cfe8933a..357c02cd 100644
--- a/src/render/pass/Pass.cpp
+++ b/src/render/pass/Pass.cpp
@@ -138,9 +138,9 @@ CRegion CRenderPass::render(const CRegion& damage_) {
m_debugData = {false};
else if (*PDEBUGPASS && !m_debugData.present) {
m_debugData.present = true;
- m_debugData.keyboardFocusText = g_pHyprOpenGL->renderText("keyboard", Colors::WHITE, 12);
- m_debugData.pointerFocusText = g_pHyprOpenGL->renderText("pointer", Colors::WHITE, 12);
- m_debugData.lastWindowText = g_pHyprOpenGL->renderText("lastWindow", Colors::WHITE, 12);
+ m_debugData.keyboardFocusText = g_pHyprRenderer->renderText("keyboard", Colors::WHITE, 12);
+ m_debugData.pointerFocusText = g_pHyprRenderer->renderText("pointer", Colors::WHITE, 12);
+ m_debugData.lastWindowText = g_pHyprRenderer->renderText("lastWindow", Colors::WHITE, 12);
}
if (WILLBLUR && !*PDEBUGPASS) {
@@ -178,7 +178,7 @@ CRegion CRenderPass::render(const CRegion& damage_) {
} else
simplify();
- g_pHyprOpenGL->m_renderData.pCurrentMonData->blurFBShouldRender = std::ranges::any_of(m_passElements, [](const auto& el) { return el->element->needsPrecomputeBlur(); });
+ g_pHyprOpenGL->m_renderData.pMonitor->m_blurFBShouldRender = std::ranges::any_of(m_passElements, [](const auto& el) { return el->element->needsPrecomputeBlur(); });
if (m_passElements.empty())
return {};
@@ -272,9 +272,9 @@ void CRenderPass::renderDebugData() {
}
const auto DISCARDED_ELEMENTS = std::ranges::count_if(m_passElements, [](const auto& e) { return e->discard; });
- auto tex = g_pHyprOpenGL->renderText(std::format("occlusion layers: {}\npass elements: {} ({} discarded)\nviewport: {:X0}", m_occludedRegions.size(), m_passElements.size(),
- DISCARDED_ELEMENTS, g_pHyprOpenGL->m_renderData.pMonitor->m_pixelSize),
- Colors::WHITE, 12);
+ auto tex = g_pHyprRenderer->renderText(std::format("occlusion layers: {}\npass elements: {} ({} discarded)\nviewport: {:X0}", m_occludedRegions.size(), m_passElements.size(),
+ DISCARDED_ELEMENTS, g_pHyprOpenGL->m_renderData.pMonitor->m_pixelSize),
+ Colors::WHITE, 12);
if (tex) {
box = CBox{{0.F, g_pHyprOpenGL->m_renderData.pMonitor->m_size.y - tex->m_size.y}, tex->m_size}.scale(g_pHyprOpenGL->m_renderData.pMonitor->m_scale);
@@ -292,7 +292,7 @@ void CRenderPass::renderDebugData() {
if (!passStructure.empty())
passStructure.pop_back();
- tex = g_pHyprOpenGL->renderText(passStructure, Colors::WHITE, 12);
+ tex = g_pHyprRenderer->renderText(passStructure, Colors::WHITE, 12);
if (tex) {
box = CBox{{g_pHyprOpenGL->m_renderData.pMonitor->m_size.x - tex->m_size.x, g_pHyprOpenGL->m_renderData.pMonitor->m_size.y - tex->m_size.y}, tex->m_size}.scale(
g_pHyprOpenGL->m_renderData.pMonitor->m_scale);
diff --git a/src/render/pass/SurfacePassElement.cpp b/src/render/pass/SurfacePassElement.cpp
index 89cd9d73..ce62998e 100644
--- a/src/render/pass/SurfacePassElement.cpp
+++ b/src/render/pass/SurfacePassElement.cpp
@@ -84,7 +84,7 @@ bool CSurfacePassElement::needsLiveBlur() {
if (m_data.popup)
return BLUR;
- const bool NEWOPTIM = g_pHyprOpenGL->shouldUseNewBlurOptimizations(m_data.pLS, m_data.pWindow);
+ const bool NEWOPTIM = g_pHyprRenderer->shouldUseNewBlurOptimizations(m_data.pLS, m_data.pWindow);
return BLUR && !NEWOPTIM;
}
@@ -101,7 +101,7 @@ bool CSurfacePassElement::needsPrecomputeBlur() {
if (m_data.popup)
return false;
- const bool NEWOPTIM = g_pHyprOpenGL->shouldUseNewBlurOptimizations(m_data.pLS, m_data.pWindow);
+ const bool NEWOPTIM = g_pHyprRenderer->shouldUseNewBlurOptimizations(m_data.pLS, m_data.pWindow);
return BLUR && NEWOPTIM;
}
diff --git a/src/render/pass/TextureMatteElement.cpp b/src/render/pass/TextureMatteElement.cpp
index a99a9ef9..f1f0ae17 100644
--- a/src/render/pass/TextureMatteElement.cpp
+++ b/src/render/pass/TextureMatteElement.cpp
@@ -1,5 +1,4 @@
#include "TextureMatteElement.hpp"
-#include "../OpenGL.hpp"
CTextureMatteElement::CTextureMatteElement(const CTextureMatteElement::STextureMatteData& data_) : m_data(data_) {
;