twin/hyprland
1
0
Fork 0
mirror of https://github.com/hyprwm/Hyprland.git synced 2025-05-19 08:30:22 -07:00
Code Issues Packages Projects Releases Wiki Activity

render: refactor class member vars (#10292)

Browse Source 
* render: refactor class member vars

* render: fix clang format
This commit is contained in:
davc0n 2025-05-05 23:44:49 +02:00 committed by GitHub
parent c7eb141098
commit 997fefbc11
No known key found for this signature in database
GPG Key ID: B5690EEEBB952194
63 changed files with 1307 additions and 1321 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

28
src/Compositor.cpp
View File

@ -136,21 +136,21 @@ static void aqLog(Aquamarine::eBackendLogLevel level, std::string msg) {
} }
void CCompositor::bumpNofile() { void CCompositor::bumpNofile() {
if (!getrlimit(RLIMIT_NOFILE, &m_sOriginalNofile)) if (!getrlimit(RLIMIT_NOFILE, &m_originalNofile))
Debug::log(LOG, "Old rlimit: soft -> {}, hard -> {}", m_sOriginalNofile.rlim_cur, m_sOriginalNofile.rlim_max); Debug::log(LOG, "Old rlimit: soft -> {}, hard -> {}", m_originalNofile.rlim_cur, m_originalNofile.rlim_max);
else { else {
Debug::log(ERR, "Failed to get NOFILE rlimits"); Debug::log(ERR, "Failed to get NOFILE rlimits");
m_sOriginalNofile.rlim_max = 0; m_originalNofile.rlim_max = 0;
return; return;
} }
rlimit newLimit = m_sOriginalNofile; rlimit newLimit = m_originalNofile;
newLimit.rlim_cur = newLimit.rlim_max; newLimit.rlim_cur = newLimit.rlim_max;
if (setrlimit(RLIMIT_NOFILE, &newLimit) < 0) { if (setrlimit(RLIMIT_NOFILE, &newLimit) < 0) {
Debug::log(ERR, "Failed bumping NOFILE limits higher"); Debug::log(ERR, "Failed bumping NOFILE limits higher");
m_sOriginalNofile.rlim_max = 0; m_originalNofile.rlim_max = 0;
return; return;
} }
@ -159,10 +159,10 @@ void CCompositor::bumpNofile() {
} }
void CCompositor::restoreNofile() { void CCompositor::restoreNofile() {
if (m_sOriginalNofile.rlim_max <= 0) if (m_originalNofile.rlim_max <= 0)
return; return;
if (setrlimit(RLIMIT_NOFILE, &m_sOriginalNofile) < 0) if (setrlimit(RLIMIT_NOFILE, &m_originalNofile) < 0)
Debug::log(ERR, "Failed restoring NOFILE limits"); Debug::log(ERR, "Failed restoring NOFILE limits");
} }
@ -176,7 +176,7 @@ void CCompositor::setMallocThreshold() {
#endif #endif
} }
CCompositor::CCompositor(bool onlyConfig) : m_onlyConfigVerification(onlyConfig), m_iHyprlandPID(getpid()) { CCompositor::CCompositor(bool onlyConfig) : m_onlyConfigVerification(onlyConfig), m_hyprlandPID(getpid()) {
if (onlyConfig) if (onlyConfig)
return; return;
@ -225,7 +225,7 @@ CCompositor::CCompositor(bool onlyConfig) : m_onlyConfigVerification(onlyConfig)
Debug::log(LOG, "Runtime directory: {}", m_instancePath); Debug::log(LOG, "Runtime directory: {}", m_instancePath);
Debug::log(LOG, "Hyprland PID: {}", m_iHyprlandPID); Debug::log(LOG, "Hyprland PID: {}", m_hyprlandPID);
Debug::log(LOG, "===== SYSTEM INFO: ====="); Debug::log(LOG, "===== SYSTEM INFO: =====");
@ -710,7 +710,7 @@ void CCompositor::createLockFile() {
std::ofstream ofs(PATH, std::ios::trunc); std::ofstream ofs(PATH, std::ios::trunc);
ofs << m_iHyprlandPID << "\n" << m_wlDisplaySocket << "\n"; ofs << m_hyprlandPID << "\n" << m_wlDisplaySocket << "\n";
ofs.close(); ofs.close();
} }
@ -2706,9 +2706,9 @@ void CCompositor::performUserChecks() {
} }
} }
if (g_pHyprOpenGL->failedAssetsNo > 0) { if (g_pHyprOpenGL->m_failedAssetsNo > 0) {
g_pHyprNotificationOverlay->addNotification(std::format("Hyprland failed to load {} essential asset{}, blame your distro's packager for doing a bad job at packaging!", g_pHyprNotificationOverlay->addNotification(std::format("Hyprland failed to load {} essential asset{}, blame your distro's packager for doing a bad job at packaging!",
g_pHyprOpenGL->failedAssetsNo, g_pHyprOpenGL->failedAssetsNo > 1 ? "s" : ""), g_pHyprOpenGL->m_failedAssetsNo, g_pHyprOpenGL->m_failedAssetsNo > 1 ? "s" : ""),
CHyprColor{1.0, 0.1, 0.1, 1.0}, 15000, ICON_ERROR); CHyprColor{1.0, 0.1, 0.1, 1.0}, 15000, ICON_ERROR);
} }
} }
@ -3033,8 +3033,8 @@ void CCompositor::onNewMonitor(SP<Aquamarine::IOutput> output) {
// ready to process if we have a real monitor // ready to process if we have a real monitor
if ((!g_pHyprRenderer->m_pMostHzMonitor || PNEWMONITOR->m_refreshRate > g_pHyprRenderer->m_pMostHzMonitor->m_refreshRate) && PNEWMONITOR->m_enabled) if ((!g_pHyprRenderer->m_mostHzMonitor || PNEWMONITOR->m_refreshRate > g_pHyprRenderer->m_mostHzMonitor->m_refreshRate) && PNEWMONITOR->m_enabled)
g_pHyprRenderer->m_pMostHzMonitor = PNEWMONITOR; g_pHyprRenderer->m_mostHzMonitor = PNEWMONITOR;
g_pCompositor->m_readyToProcess = true; g_pCompositor->m_readyToProcess = true;

8
src/Compositor.hpp
View File

@ -152,7 +152,7 @@ class CCompositor {
NColorManagement::SImageDescription getPreferredImageDescription(); NColorManagement::SImageDescription getPreferredImageDescription();
bool shouldChangePreferredImageDescription(); bool shouldChangePreferredImageDescription();
std::string explicitConfigPath; std::string m_explicitConfigPath;
private: private:
void initAllSignals(); void initAllSignals();
@ -165,9 +165,9 @@ class CCompositor {
void removeLockFile(); void removeLockFile();
void setMallocThreshold(); void setMallocThreshold();
uint64_t m_iHyprlandPID = 0; uint64_t m_hyprlandPID = 0;
wl_event_source* m_critSigSource = nullptr; wl_event_source* m_critSigSource = nullptr;
rlimit m_sOriginalNofile = {}; rlimit m_originalNofile = {};
}; };
inline UP<CCompositor> g_pCompositor; inline UP<CCompositor> g_pCompositor;

6
src/config/ConfigManager.cpp
View File

@ -857,8 +857,8 @@ std::optional<std::string> CConfigManager::generateConfig(std::string configPath
std::string CConfigManager::getMainConfigPath() { std::string CConfigManager::getMainConfigPath() {
static std::string CONFIG_PATH = [this]() -> std::string { static std::string CONFIG_PATH = [this]() -> std::string {
if (!g_pCompositor->explicitConfigPath.empty()) if (!g_pCompositor->m_explicitConfigPath.empty())
return g_pCompositor->explicitConfigPath; return g_pCompositor->m_explicitConfigPath;
if (const auto CFG_ENV = getenv("HYPRLAND_CONFIG"); CFG_ENV) if (const auto CFG_ENV = getenv("HYPRLAND_CONFIG"); CFG_ENV)
return CFG_ENV; return CFG_ENV;
@ -1025,7 +1025,7 @@ void CConfigManager::postConfigReload(const Hyprlang::CParseResult& result) {
g_pInputManager->setTouchDeviceConfigs(); g_pInputManager->setTouchDeviceConfigs();
g_pInputManager->setTabletConfigs(); g_pInputManager->setTabletConfigs();
g_pHyprOpenGL->m_bReloadScreenShader = true; g_pHyprOpenGL->m_reloadScreenShader = true;
g_pHyprOpenGL->ensureBackgroundTexturePresence(); g_pHyprOpenGL->ensureBackgroundTexturePresence();
} }

8
src/debug/HyprCtl.cpp
View File

@ -1128,10 +1128,10 @@ static std::string dispatchKeyword(eHyprCtlOutputFormat format, std::string in)
g_pLayoutManager->switchToLayout(*PLAYOUT); // update layout g_pLayoutManager->switchToLayout(*PLAYOUT); // update layout
if (COMMAND.contains("decoration:screen_shader") || COMMAND == "source") if (COMMAND.contains("decoration:screen_shader") || COMMAND == "source")
g_pHyprOpenGL->m_bReloadScreenShader = true; g_pHyprOpenGL->m_reloadScreenShader = true;
if (COMMAND.contains("blur") || COMMAND == "source") { if (COMMAND.contains("blur") || COMMAND == "source") {
for (auto& [m, rd] : g_pHyprOpenGL->m_mMonitorRenderResources) { for (auto& [m, rd] : g_pHyprOpenGL->m_monitorRenderResources) {
rd.blurFBDirty = true; rd.blurFBDirty = true;
} }
} }
@ -1821,9 +1821,9 @@ std::string CHyprCtl::getReply(std::string request) {
g_pLayoutManager->switchToLayout(*PLAYOUT); // update layout g_pLayoutManager->switchToLayout(*PLAYOUT); // update layout
g_pHyprOpenGL->m_bReloadScreenShader = true; g_pHyprOpenGL->m_reloadScreenShader = true;
for (auto& [m, rd] : g_pHyprOpenGL->m_mMonitorRenderResources) { for (auto& [m, rd] : g_pHyprOpenGL->m_monitorRenderResources) {
rd.blurFBDirty = true; rd.blurFBDirty = true;
} }

6
src/debug/HyprDebugOverlay.cpp
View File

@ -57,7 +57,7 @@ void CHyprMonitorDebugOverlay::frameData(PHLMONITOR pMonitor) {
m_monitor = pMonitor; m_monitor = pMonitor;
// anim data too // anim data too
const auto PMONITORFORTICKS = g_pHyprRenderer->m_pMostHzMonitor ? g_pHyprRenderer->m_pMostHzMonitor.lock() : g_pCompositor->m_lastMonitor.lock(); const auto PMONITORFORTICKS = g_pHyprRenderer->m_mostHzMonitor ? g_pHyprRenderer->m_mostHzMonitor.lock() : g_pCompositor->m_lastMonitor.lock();
if (PMONITORFORTICKS) { if (PMONITORFORTICKS) {
if (m_lastAnimationTicks.size() > (long unsigned int)PMONITORFORTICKS->m_refreshRate) if (m_lastAnimationTicks.size() > (long unsigned int)PMONITORFORTICKS->m_refreshRate)
m_lastAnimationTicks.pop_front(); m_lastAnimationTicks.pop_front();
@ -260,7 +260,7 @@ void CHyprDebugOverlay::draw() {
// copy the data to an OpenGL texture we have // copy the data to an OpenGL texture we have
const auto DATA = cairo_image_surface_get_data(m_cairoSurface); const auto DATA = cairo_image_surface_get_data(m_cairoSurface);
m_texture->allocate(); m_texture->allocate();
glBindTexture(GL_TEXTURE_2D, m_texture->m_iTexID); glBindTexture(GL_TEXTURE_2D, m_texture->m_texID);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
@ -274,5 +274,5 @@ void CHyprDebugOverlay::draw() {
CTexPassElement::SRenderData data; CTexPassElement::SRenderData data;
data.tex = m_texture; data.tex = m_texture;
data.box = {0, 0, PMONITOR->m_pixelSize.x, PMONITOR->m_pixelSize.y}; data.box = {0, 0, PMONITOR->m_pixelSize.x, PMONITOR->m_pixelSize.y};
g_pHyprRenderer->m_sRenderPass.add(makeShared<CTexPassElement>(data)); g_pHyprRenderer->m_renderPass.add(makeShared<CTexPassElement>(data));
} }

4
src/debug/HyprNotificationOverlay.cpp
View File

@ -235,7 +235,7 @@ void CHyprNotificationOverlay::draw(PHLMONITOR pMonitor) {
// copy the data to an OpenGL texture we have // copy the data to an OpenGL texture we have
const auto DATA = cairo_image_surface_get_data(m_cairoSurface); const auto DATA = cairo_image_surface_get_data(m_cairoSurface);
m_texture->allocate(); m_texture->allocate();
glBindTexture(GL_TEXTURE_2D, m_texture->m_iTexID); glBindTexture(GL_TEXTURE_2D, m_texture->m_texID);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
@ -251,7 +251,7 @@ void CHyprNotificationOverlay::draw(PHLMONITOR pMonitor) {
data.box = {0, 0, MONSIZE.x, MONSIZE.y}; data.box = {0, 0, MONSIZE.x, MONSIZE.y};
data.a = 1.F; data.a = 1.F;
g_pHyprRenderer->m_sRenderPass.add(makeShared<CTexPassElement>(data)); g_pHyprRenderer->m_renderPass.add(makeShared<CTexPassElement>(data));
} }
bool CHyprNotificationOverlay::hasAny() { bool CHyprNotificationOverlay::hasAny() {

2
src/desktop/LayerSurface.cpp
View File

@ -74,7 +74,7 @@ CLayerSurface::~CLayerSurface() {
if (m_surface) if (m_surface)
m_surface->unassign(); m_surface->unassign();
g_pHyprRenderer->makeEGLCurrent(); g_pHyprRenderer->makeEGLCurrent();
std::erase_if(g_pHyprOpenGL->m_mLayerFramebuffers, [&](const auto& other) { return other.first.expired() || other.first.lock() == m_self.lock(); }); std::erase_if(g_pHyprOpenGL->m_layerFramebuffers, [&](const auto& other) { return other.first.expired() || other.first.lock() == m_self.lock(); });
for (auto const& mon : g_pCompositor->m_realMonitors) { for (auto const& mon : g_pCompositor->m_realMonitors) {
for (auto& lsl : mon->m_layerSurfaceLayers) { for (auto& lsl : mon->m_layerSurfaceLayers) {

4
src/desktop/WLSurface.cpp
View File

@ -143,8 +143,8 @@ void CWLSurface::destroy() {
m_subsurfaceOwner = nullptr; m_subsurfaceOwner = nullptr;
m_inert = true; m_inert = true;
if (g_pHyprRenderer && g_pHyprRenderer->m_sLastCursorData.surf && g_pHyprRenderer->m_sLastCursorData.surf->get() == this) if (g_pHyprRenderer && g_pHyprRenderer->m_lastCursorData.surf && g_pHyprRenderer->m_lastCursorData.surf->get() == this)
g_pHyprRenderer->m_sLastCursorData.surf.reset(); g_pHyprRenderer->m_lastCursorData.surf.reset();
m_resource.reset(); m_resource.reset();

6
src/desktop/Window.cpp
View File

@ -126,7 +126,7 @@ CWindow::~CWindow() {
return; return;
g_pHyprRenderer->makeEGLCurrent(); g_pHyprRenderer->makeEGLCurrent();
std::erase_if(g_pHyprOpenGL->m_mWindowFramebuffers, [&](const auto& other) { return other.first.expired() || other.first.get() == this; }); std::erase_if(g_pHyprOpenGL->m_windowFramebuffers, [&](const auto& other) { return other.first.expired() || other.first.get() == this; });
} }
SBoxExtents CWindow::getFullWindowExtents() { SBoxExtents CWindow::getFullWindowExtents() {
@ -1160,7 +1160,7 @@ bool CWindow::opaque() {
return false; return false;
if (m_isX11 && m_xwaylandSurface && m_xwaylandSurface->surface && m_xwaylandSurface->surface->m_current.texture) if (m_isX11 && m_xwaylandSurface && m_xwaylandSurface->surface && m_xwaylandSurface->surface->m_current.texture)
return m_xwaylandSurface->surface->m_current.texture->m_bOpaque; return m_xwaylandSurface->surface->m_current.texture->m_opaque;
if (!m_wlSurface->resource() || !m_wlSurface->resource()->m_current.texture) if (!m_wlSurface->resource() || !m_wlSurface->resource()->m_current.texture)
return false; return false;
@ -1170,7 +1170,7 @@ bool CWindow::opaque() {
if (EXTENTS.w >= m_xdgSurface->m_surface->m_current.bufferSize.x && EXTENTS.h >= m_xdgSurface->m_surface->m_current.bufferSize.y) if (EXTENTS.w >= m_xdgSurface->m_surface->m_current.bufferSize.x && EXTENTS.h >= m_xdgSurface->m_surface->m_current.bufferSize.y)
return true; return true;
return m_wlSurface->resource()->m_current.texture->m_bOpaque; return m_wlSurface->resource()->m_current.texture->m_opaque;
} }
float CWindow::rounding() { float CWindow::rounding() {

8
src/helpers/Monitor.cpp
View File

@ -388,7 +388,7 @@ void CMonitor::onDisconnect(bool destroy) {
if (g_pCompositor->m_lastMonitor == m_self) if (g_pCompositor->m_lastMonitor == m_self)
g_pCompositor->setActiveMonitor(BACKUPMON ? BACKUPMON : g_pCompositor->m_unsafeOutput.lock()); g_pCompositor->setActiveMonitor(BACKUPMON ? BACKUPMON : g_pCompositor->m_unsafeOutput.lock());
if (g_pHyprRenderer->m_pMostHzMonitor == m_self) { if (g_pHyprRenderer->m_mostHzMonitor == m_self) {
int mostHz = 0; int mostHz = 0;
PHLMONITOR pMonitorMostHz = nullptr; PHLMONITOR pMonitorMostHz = nullptr;
@ -399,7 +399,7 @@ void CMonitor::onDisconnect(bool destroy) {
} }
} }
g_pHyprRenderer->m_pMostHzMonitor = pMonitorMostHz; g_pHyprRenderer->m_mostHzMonitor = pMonitorMostHz;
} }
std::erase_if(g_pCompositor->m_monitors, [&](PHLMONITOR& el) { return el.get() == this; }); std::erase_if(g_pCompositor->m_monitors, [&](PHLMONITOR& el) { return el.get() == this; });
} }
@ -1362,7 +1362,7 @@ void CMonitor::setCTM(const Mat3x3& ctm_) {
} }
bool CMonitor::attemptDirectScanout() { bool CMonitor::attemptDirectScanout() {
if (!m_mirrors.empty() || isMirror() || g_pHyprRenderer->m_bDirectScanoutBlocked) if (!m_mirrors.empty() || isMirror() || g_pHyprRenderer->m_directScanoutBlocked)
return false; // do not DS if this monitor is being mirrored. Will break the functionality. return false; // do not DS if this monitor is being mirrored. Will break the functionality.
if (g_pPointerManager->softwareLockedFor(m_self.lock())) if (g_pPointerManager->softwareLockedFor(m_self.lock()))
@ -1383,7 +1383,7 @@ bool CMonitor::attemptDirectScanout() {
// we can't scanout shm buffers. // we can't scanout shm buffers.
const auto params = PSURFACE->m_current.buffer->dmabuf(); const auto params = PSURFACE->m_current.buffer->dmabuf();
if (!params.success || !PSURFACE->m_current.texture->m_pEglImage /* dmabuf */) if (!params.success || !PSURFACE->m_current.texture->m_eglImage /* dmabuf */)
return false; return false;
Debug::log(TRACE, "attemptDirectScanout: surface {:x} passed, will attempt, buffer {}", (uintptr_t)PSURFACE.get(), (uintptr_t)PSURFACE->m_current.buffer.m_buffer.get()); Debug::log(TRACE, "attemptDirectScanout: surface {:x} passed, will attempt, buffer {}", (uintptr_t)PSURFACE.get(), (uintptr_t)PSURFACE->m_current.buffer.m_buffer.get());

6
src/hyprerror/HyprError.cpp
View File

@ -143,7 +143,7 @@ void CHyprError::createQueued() {
// copy the data to an OpenGL texture we have // copy the data to an OpenGL texture we have
const auto DATA = cairo_image_surface_get_data(CAIROSURFACE); const auto DATA = cairo_image_surface_get_data(CAIROSURFACE);
m_texture->allocate(); m_texture->allocate();
glBindTexture(GL_TEXTURE_2D, m_texture->m_iTexID); glBindTexture(GL_TEXTURE_2D, m_texture->m_texID);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
@ -194,7 +194,7 @@ void CHyprError::draw() {
} }
} }
const auto PMONITOR = g_pHyprOpenGL->m_RenderData.pMonitor; const auto PMONITOR = g_pHyprOpenGL->m_renderData.pMonitor;
CBox monbox = {0, 0, PMONITOR->m_pixelSize.x, PMONITOR->m_pixelSize.y}; CBox monbox = {0, 0, PMONITOR->m_pixelSize.x, PMONITOR->m_pixelSize.y};
@ -211,7 +211,7 @@ void CHyprError::draw() {
data.box = monbox; data.box = monbox;
data.a = m_fadeOpacity->value(); data.a = m_fadeOpacity->value();
g_pHyprRenderer->m_sRenderPass.add(makeShared<CTexPassElement>(data)); g_pHyprRenderer->m_renderPass.add(makeShared<CTexPassElement>(data));
} }
void CHyprError::destroy() { void CHyprError::destroy() {

2
src/layout/IHyprLayout.cpp
View File

@ -553,7 +553,7 @@ void IHyprLayout::onMouseMove(const Vector2D& mousePos) {
const auto TIMERDELTA = std::chrono::duration_cast<std::chrono::milliseconds>(std::chrono::high_resolution_clock::now() - TIMER).count(); const auto TIMERDELTA = std::chrono::duration_cast<std::chrono::milliseconds>(std::chrono::high_resolution_clock::now() - TIMER).count();
const auto MSDELTA = std::chrono::duration_cast<std::chrono::milliseconds>(std::chrono::high_resolution_clock::now() - MSTIMER).count(); const auto MSDELTA = std::chrono::duration_cast<std::chrono::milliseconds>(std::chrono::high_resolution_clock::now() - MSTIMER).count();
const auto MSMONITOR = 1000.0 / g_pHyprRenderer->m_pMostHzMonitor->m_refreshRate; const auto MSMONITOR = 1000.0 / g_pHyprRenderer->m_mostHzMonitor->m_refreshRate;
static int totalMs = 0; static int totalMs = 0;
bool canSkipUpdate = true; bool canSkipUpdate = true;

4
src/main.cpp
View File

@ -160,8 +160,8 @@ int main(int argc, char** argv) {
// let's init the compositor. // let's init the compositor.
// it initializes basic Wayland stuff in the constructor. // it initializes basic Wayland stuff in the constructor.
try { try {
g_pCompositor = makeUnique<CCompositor>(verifyConfig); g_pCompositor = makeUnique<CCompositor>(verifyConfig);
g_pCompositor->explicitConfigPath = configPath; g_pCompositor->m_explicitConfigPath = configPath;
} catch (const std::exception& e) { } catch (const std::exception& e) {
std::println(stderr, "Hyprland threw in ctor: {}\nCannot continue.", e.what()); std::println(stderr, "Hyprland threw in ctor: {}\nCannot continue.", e.what());
return 1; return 1;

2
src/managers/AnimationManager.cpp
View File

@ -255,7 +255,7 @@ void CHyprAnimationManager::scheduleTick() {
m_tickScheduled = true; m_tickScheduled = true;
const auto PMOSTHZ = g_pHyprRenderer->m_pMostHzMonitor; const auto PMOSTHZ = g_pHyprRenderer->m_mostHzMonitor;
if (!PMOSTHZ) { if (!PMOSTHZ) {
m_animationTimer->updateTimeout(std::chrono::milliseconds(16)); m_animationTimer->updateTimeout(std::chrono::milliseconds(16));

20
src/managers/PointerManager.cpp
View File

@ -471,11 +471,11 @@ SP<Aquamarine::IBuffer> CPointerManager::renderHWCursorBuffer(SP<CPointerManager
bool flipRB = false; bool flipRB = false;
if (SURFACE->m_current.texture) { if (SURFACE->m_current.texture) {
Debug::log(TRACE, "Cursor CPU surface: format {}, expecting AR24", NFormatUtils::drmFormatName(SURFACE->m_current.texture->m_iDrmFormat)); Debug::log(TRACE, "Cursor CPU surface: format {}, expecting AR24", NFormatUtils::drmFormatName(SURFACE->m_current.texture->m_drmFormat));
if (SURFACE->m_current.texture->m_iDrmFormat == DRM_FORMAT_ABGR8888) { if (SURFACE->m_current.texture->m_drmFormat == DRM_FORMAT_ABGR8888) {
Debug::log(TRACE, "Cursor CPU surface format AB24, will flip. WARNING: this will break on big endian!"); Debug::log(TRACE, "Cursor CPU surface format AB24, will flip. WARNING: this will break on big endian!");
flipRB = true; flipRB = true;
} else if (SURFACE->m_current.texture->m_iDrmFormat != DRM_FORMAT_ARGB8888) { } else if (SURFACE->m_current.texture->m_drmFormat != DRM_FORMAT_ARGB8888) {
Debug::log(TRACE, "Cursor CPU surface format rejected, falling back to sw"); Debug::log(TRACE, "Cursor CPU surface format rejected, falling back to sw");
return nullptr; return nullptr;
} }
@ -484,7 +484,7 @@ SP<Aquamarine::IBuffer> CPointerManager::renderHWCursorBuffer(SP<CPointerManager
if (shmBuffer.data()) if (shmBuffer.data())
texData = shmBuffer; texData = shmBuffer;
else { else {
texData.resize(texture->m_vSize.x * 4 * texture->m_vSize.y); texData.resize(texture->m_size.x * 4 * texture->m_size.y);
memset(texData.data(), 0x00, texData.size()); memset(texData.data(), 0x00, texData.size());
} }
@ -506,13 +506,13 @@ SP<Aquamarine::IBuffer> CPointerManager::renderHWCursorBuffer(SP<CPointerManager
auto CAIROSURFACE = cairo_image_surface_create(CAIRO_FORMAT_ARGB32, DMABUF.size.x, DMABUF.size.y); auto CAIROSURFACE = cairo_image_surface_create(CAIRO_FORMAT_ARGB32, DMABUF.size.x, DMABUF.size.y);
auto CAIRODATASURFACE = auto CAIRODATASURFACE =
cairo_image_surface_create_for_data((unsigned char*)texData.data(), CAIRO_FORMAT_ARGB32, texture->m_vSize.x, texture->m_vSize.y, texture->m_vSize.x * 4); cairo_image_surface_create_for_data((unsigned char*)texData.data(), CAIRO_FORMAT_ARGB32, texture->m_size.x, texture->m_size.y, texture->m_size.x * 4);
auto CAIRO = cairo_create(CAIROSURFACE); auto CAIRO = cairo_create(CAIROSURFACE);
cairo_set_operator(CAIRO, CAIRO_OPERATOR_SOURCE); cairo_set_operator(CAIRO, CAIRO_OPERATOR_SOURCE);
cairo_set_source_rgba(CAIRO, 0, 0, 0, 0); cairo_set_source_rgba(CAIRO, 0, 0, 0, 0);
cairo_rectangle(CAIRO, 0, 0, texture->m_vSize.x, texture->m_vSize.y); cairo_rectangle(CAIRO, 0, 0, texture->m_size.x, texture->m_size.y);
cairo_fill(CAIRO); cairo_fill(CAIRO);
const auto PATTERNPRE = cairo_pattern_create_for_surface(CAIRODATASURFACE); const auto PATTERNPRE = cairo_pattern_create_for_surface(CAIRODATASURFACE);
@ -523,7 +523,7 @@ SP<Aquamarine::IBuffer> CPointerManager::renderHWCursorBuffer(SP<CPointerManager
const auto TR = state->monitor->m_transform; const auto TR = state->monitor->m_transform;
// we need to scale the cursor to the right size, because it might not be (esp with XCursor) // we need to scale the cursor to the right size, because it might not be (esp with XCursor)
const auto SCALE = texture->m_vSize / (m_currentCursorImage.size / m_currentCursorImage.scale * state->monitor->m_scale); const auto SCALE = texture->m_size / (m_currentCursorImage.size / m_currentCursorImage.scale * state->monitor->m_scale);
cairo_matrix_scale(&matrixPre, SCALE.x, SCALE.y); cairo_matrix_scale(&matrixPre, SCALE.x, SCALE.y);
if (TR) { if (TR) {
@ -564,7 +564,7 @@ SP<Aquamarine::IBuffer> CPointerManager::renderHWCursorBuffer(SP<CPointerManager
} }
g_pHyprRenderer->makeEGLCurrent(); g_pHyprRenderer->makeEGLCurrent();
g_pHyprOpenGL->m_RenderData.pMonitor = state->monitor; g_pHyprOpenGL->m_renderData.pMonitor = state->monitor;
auto RBO = g_pHyprRenderer->getOrCreateRenderbuffer(buf, state->monitor->m_cursorSwapchain->currentOptions().format); auto RBO = g_pHyprRenderer->getOrCreateRenderbuffer(buf, state->monitor->m_cursorSwapchain->currentOptions().format);
if (!RBO) { if (!RBO) {
@ -585,7 +585,7 @@ SP<Aquamarine::IBuffer> CPointerManager::renderHWCursorBuffer(SP<CPointerManager
g_pHyprOpenGL->end(); g_pHyprOpenGL->end();
glFlush(); glFlush();
g_pHyprOpenGL->m_RenderData.pMonitor.reset(); g_pHyprOpenGL->m_renderData.pMonitor.reset();
g_pHyprRenderer->onRenderbufferDestroy(RBO.get()); g_pHyprRenderer->onRenderbufferDestroy(RBO.get());
@ -625,7 +625,7 @@ void CPointerManager::renderSoftwareCursorsFor(PHLMONITOR pMonitor, const Time::
data.tex = texture; data.tex = texture;
data.box = box.round(); data.box = box.round();
g_pHyprRenderer->m_sRenderPass.add(makeShared<CTexPassElement>(data)); g_pHyprRenderer->m_renderPass.add(makeShared<CTexPassElement>(data));
if (m_currentCursorImage.surface) if (m_currentCursorImage.surface)
m_currentCursorImage.surface->resource()->frame(now); m_currentCursorImage.surface->resource()->frame(now);

22
src/protocols/Screencopy.cpp
View File

@ -146,7 +146,7 @@ void CScreencopyFrame::copy(CZwlrScreencopyFrameV1* pFrame, wl_resource* buffer_
PROTO::screencopy->m_framesAwaitingWrite.emplace_back(m_self); PROTO::screencopy->m_framesAwaitingWrite.emplace_back(m_self);
g_pHyprRenderer->m_bDirectScanoutBlocked = true; g_pHyprRenderer->m_directScanoutBlocked = true;
if (!m_withDamage) if (!m_withDamage)
g_pHyprRenderer->damageMonitor(m_monitor.lock()); g_pHyprRenderer->damageMonitor(m_monitor.lock());
@ -215,12 +215,11 @@ void CScreencopyFrame::copyDmabuf(std::function<void(bool)> callback) {
g_pHyprOpenGL->clear(Colors::BLACK); g_pHyprOpenGL->clear(Colors::BLACK);
else { else {
g_pHyprOpenGL->clear(Colors::BLACK); g_pHyprOpenGL->clear(Colors::BLACK);
CBox texbox = CBox texbox = CBox{m_monitor->m_transformedSize / 2.F, g_pHyprOpenGL->m_screencopyDeniedTexture->m_size}.translate(-g_pHyprOpenGL->m_screencopyDeniedTexture->m_size / 2.F);
CBox{m_monitor->m_transformedSize / 2.F, g_pHyprOpenGL->m_pScreencopyDeniedTexture->m_vSize}.translate(-g_pHyprOpenGL->m_pScreencopyDeniedTexture->m_vSize / 2.F); g_pHyprOpenGL->renderTexture(g_pHyprOpenGL->m_screencopyDeniedTexture, texbox, 1);
g_pHyprOpenGL->renderTexture(g_pHyprOpenGL->m_pScreencopyDeniedTexture, texbox, 1);
} }
g_pHyprOpenGL->m_RenderData.blockScreenShader = true; g_pHyprOpenGL->m_renderData.blockScreenShader = true;
g_pHyprRenderer->endRender([callback]() { g_pHyprRenderer->endRender([callback]() {
LOGM(TRACE, "Copied frame via dma"); LOGM(TRACE, "Copied frame via dma");
@ -261,9 +260,8 @@ bool CScreencopyFrame::copyShm() {
g_pHyprOpenGL->clear(Colors::BLACK); g_pHyprOpenGL->clear(Colors::BLACK);
else { else {
g_pHyprOpenGL->clear(Colors::BLACK); g_pHyprOpenGL->clear(Colors::BLACK);
CBox texbox = CBox texbox = CBox{m_monitor->m_transformedSize / 2.F, g_pHyprOpenGL->m_screencopyDeniedTexture->m_size}.translate(-g_pHyprOpenGL->m_screencopyDeniedTexture->m_size / 2.F);
CBox{m_monitor->m_transformedSize / 2.F, g_pHyprOpenGL->m_pScreencopyDeniedTexture->m_vSize}.translate(-g_pHyprOpenGL->m_pScreencopyDeniedTexture->m_vSize / 2.F); g_pHyprOpenGL->renderTexture(g_pHyprOpenGL->m_screencopyDeniedTexture, texbox, 1);
g_pHyprOpenGL->renderTexture(g_pHyprOpenGL->m_pScreencopyDeniedTexture, texbox, 1);
} }
#ifndef GLES2 #ifndef GLES2
@ -281,11 +279,11 @@ bool CScreencopyFrame::copyShm() {
auto glFormat = PFORMAT->flipRB ? GL_BGRA_EXT : GL_RGBA; auto glFormat = PFORMAT->flipRB ? GL_BGRA_EXT : GL_RGBA;
g_pHyprOpenGL->m_RenderData.blockScreenShader = true; g_pHyprOpenGL->m_renderData.blockScreenShader = true;
g_pHyprRenderer->endRender(); g_pHyprRenderer->endRender();
g_pHyprRenderer->makeEGLCurrent(); g_pHyprRenderer->makeEGLCurrent();
g_pHyprOpenGL->m_RenderData.pMonitor = m_monitor; g_pHyprOpenGL->m_renderData.pMonitor = m_monitor;
fb.bind(); fb.bind();
glPixelStorei(GL_PACK_ALIGNMENT, 1); glPixelStorei(GL_PACK_ALIGNMENT, 1);
@ -304,7 +302,7 @@ bool CScreencopyFrame::copyShm() {
} }
} }
g_pHyprOpenGL->m_RenderData.pMonitor.reset(); g_pHyprOpenGL->m_renderData.pMonitor.reset();
#ifndef GLES2 #ifndef GLES2
glBindFramebuffer(GL_READ_FRAMEBUFFER, 0); glBindFramebuffer(GL_READ_FRAMEBUFFER, 0);
@ -414,7 +412,7 @@ void CScreencopyProtocol::destroyResource(CScreencopyFrame* frame) {
void CScreencopyProtocol::onOutputCommit(PHLMONITOR pMonitor) { void CScreencopyProtocol::onOutputCommit(PHLMONITOR pMonitor) {
if (m_framesAwaitingWrite.empty()) { if (m_framesAwaitingWrite.empty()) {
g_pHyprRenderer->m_bDirectScanoutBlocked = false; g_pHyprRenderer->m_directScanoutBlocked = false;
return; // nothing to share return; // nothing to share
} }

2
src/protocols/SinglePixel.cpp
View File

@ -16,7 +16,7 @@ CSinglePixelBuffer::CSinglePixelBuffer(uint32_t id, wl_client* client, CHyprColo
m_resource = CWLBufferResource::create(makeShared<CWlBuffer>(client, 1, id)); m_resource = CWLBufferResource::create(makeShared<CWlBuffer>(client, 1, id));
m_success = m_texture->m_iTexID; m_success = m_texture->m_texID;
size = {1, 1}; size = {1, 1};

16
src/protocols/ToplevelExport.cpp
View File

@ -264,9 +264,8 @@ bool CToplevelExportFrame::copyShm(const Time::steady_tp& now) {
if (overlayCursor) if (overlayCursor)
g_pPointerManager->renderSoftwareCursorsFor(PMONITOR->m_self.lock(), now, fakeDamage, g_pInputManager->getMouseCoordsInternal() - m_window->m_realPosition->value()); g_pPointerManager->renderSoftwareCursorsFor(PMONITOR->m_self.lock(), now, fakeDamage, g_pInputManager->getMouseCoordsInternal() - m_window->m_realPosition->value());
} else if (PERM == PERMISSION_RULE_ALLOW_MODE_DENY) { } else if (PERM == PERMISSION_RULE_ALLOW_MODE_DENY) {
CBox texbox = CBox texbox = CBox{PMONITOR->m_transformedSize / 2.F, g_pHyprOpenGL->m_screencopyDeniedTexture->m_size}.translate(-g_pHyprOpenGL->m_screencopyDeniedTexture->m_size / 2.F);
CBox{PMONITOR->m_transformedSize / 2.F, g_pHyprOpenGL->m_pScreencopyDeniedTexture->m_vSize}.translate(-g_pHyprOpenGL->m_pScreencopyDeniedTexture->m_vSize / 2.F); g_pHyprOpenGL->renderTexture(g_pHyprOpenGL->m_screencopyDeniedTexture, texbox, 1);
g_pHyprOpenGL->renderTexture(g_pHyprOpenGL->m_pScreencopyDeniedTexture, texbox, 1);
} }
const auto PFORMAT = NFormatUtils::getPixelFormatFromDRM(shm.format); const auto PFORMAT = NFormatUtils::getPixelFormatFromDRM(shm.format);
@ -275,11 +274,11 @@ bool CToplevelExportFrame::copyShm(const Time::steady_tp& now) {
return false; return false;
} }
g_pHyprOpenGL->m_RenderData.blockScreenShader = true; g_pHyprOpenGL->m_renderData.blockScreenShader = true;
g_pHyprRenderer->endRender(); g_pHyprRenderer->endRender();
g_pHyprRenderer->makeEGLCurrent(); g_pHyprRenderer->makeEGLCurrent();
g_pHyprOpenGL->m_RenderData.pMonitor = PMONITOR; g_pHyprOpenGL->m_renderData.pMonitor = PMONITOR;
outFB.bind(); outFB.bind();
#ifndef GLES2 #ifndef GLES2
@ -352,12 +351,11 @@ bool CToplevelExportFrame::copyDmabuf(const Time::steady_tp& now) {
if (overlayCursor) if (overlayCursor)
g_pPointerManager->renderSoftwareCursorsFor(PMONITOR->m_self.lock(), now, fakeDamage, g_pInputManager->getMouseCoordsInternal() - m_window->m_realPosition->value()); g_pPointerManager->renderSoftwareCursorsFor(PMONITOR->m_self.lock(), now, fakeDamage, g_pInputManager->getMouseCoordsInternal() - m_window->m_realPosition->value());
} else if (PERM == PERMISSION_RULE_ALLOW_MODE_DENY) { } else if (PERM == PERMISSION_RULE_ALLOW_MODE_DENY) {
CBox texbox = CBox texbox = CBox{PMONITOR->m_transformedSize / 2.F, g_pHyprOpenGL->m_screencopyDeniedTexture->m_size}.translate(-g_pHyprOpenGL->m_screencopyDeniedTexture->m_size / 2.F);
CBox{PMONITOR->m_transformedSize / 2.F, g_pHyprOpenGL->m_pScreencopyDeniedTexture->m_vSize}.translate(-g_pHyprOpenGL->m_pScreencopyDeniedTexture->m_vSize / 2.F); g_pHyprOpenGL->renderTexture(g_pHyprOpenGL->m_screencopyDeniedTexture, texbox, 1);
g_pHyprOpenGL->renderTexture(g_pHyprOpenGL->m_pScreencopyDeniedTexture, texbox, 1);
} }
g_pHyprOpenGL->m_RenderData.blockScreenShader = true; g_pHyprOpenGL->m_renderData.blockScreenShader = true;
g_pHyprRenderer->endRender(); g_pHyprRenderer->endRender();
if (overlayCursor) { if (overlayCursor) {

2
src/protocols/core/Compositor.cpp
View File

@ -495,7 +495,7 @@ void CWLSurfaceResource::commitState(SSurfaceState& state) {
} }
if (m_current.texture) if (m_current.texture)
m_current.texture->m_eTransform = wlTransformToHyprutils(m_current.transform); m_current.texture->m_transform = wlTransformToHyprutils(m_current.transform);
if (m_role->role() == SURFACE_ROLE_SUBSURFACE) { if (m_role->role() == SURFACE_ROLE_SUBSURFACE) {
auto subsurface = ((CSubsurfaceRole*)m_role.get())->m_subsurface.lock(); auto subsurface = ((CSubsurfaceRole*)m_role.get())->m_subsurface.lock();

2
src/protocols/core/DataDevice.cpp
View File

@ -814,7 +814,7 @@ void CWLDataDeviceProtocol::renderDND(PHLMONITOR pMonitor, const Time::steady_tp
CTexPassElement::SRenderData data; CTexPassElement::SRenderData data;
data.tex = m_dnd.dndSurface->m_current.texture; data.tex = m_dnd.dndSurface->m_current.texture;
data.box = box; data.box = box;
g_pHyprRenderer->m_sRenderPass.add(makeShared<CTexPassElement>(data)); g_pHyprRenderer->m_renderPass.add(makeShared<CTexPassElement>(data));
CBox damageBox = CBox{surfacePos, m_dnd.dndSurface->m_current.size}.expand(5); CBox damageBox = CBox{surfacePos, m_dnd.dndSurface->m_current.size}.expand(5);
g_pHyprRenderer->damageBox(damageBox); g_pHyprRenderer->damageBox(damageBox);

2
src/protocols/types/DMABuffer.cpp
View File

@ -37,7 +37,7 @@ CDMABuffer::CDMABuffer(uint32_t id, wl_client* client, Aquamarine::SDMABUFAttrs
m_texture = makeShared<CTexture>(m_attrs, eglImage); // texture takes ownership of the eglImage m_texture = makeShared<CTexture>(m_attrs, eglImage); // texture takes ownership of the eglImage
m_opaque = NFormatUtils::isFormatOpaque(m_attrs.format); m_opaque = NFormatUtils::isFormatOpaque(m_attrs.format);
m_success = m_texture->m_iTexID; m_success = m_texture->m_texID;
if UNLIKELY (!m_success) if UNLIKELY (!m_success)
Debug::log(ERR, "Failed to create a dmabuf: texture is null"); Debug::log(ERR, "Failed to create a dmabuf: texture is null");

2
src/protocols/types/SurfaceState.cpp
View File

@ -39,7 +39,7 @@ void SSurfaceState::updateSynchronousTexture(SP<CTexture> lastTexture) {
if (dataPtr) { if (dataPtr) {
auto drmFmt = NFormatUtils::shmToDRM(fmt); auto drmFmt = NFormatUtils::shmToDRM(fmt);
auto stride = bufferSize.y ? size / bufferSize.y : 0; auto stride = bufferSize.y ? size / bufferSize.y : 0;
if (lastTexture && lastTexture->m_isSynchronous && lastTexture->m_vSize == bufferSize) { if (lastTexture && lastTexture->m_isSynchronous && lastTexture->m_size == bufferSize) {
texture = lastTexture; texture = lastTexture;
texture->update(drmFmt, dataPtr, stride, accumulateBufferDamage()); texture->update(drmFmt, dataPtr, stride, accumulateBufferDamage());
} else } else

72
src/render/Framebuffer.cpp
View File

@ -12,10 +12,10 @@ bool CFramebuffer::alloc(int w, int h, uint32_t drmFormat) {
uint32_t glFormat = NFormatUtils::drmFormatToGL(drmFormat); uint32_t glFormat = NFormatUtils::drmFormatToGL(drmFormat);
uint32_t glType = NFormatUtils::glFormatToType(glFormat); uint32_t glType = NFormatUtils::glFormatToType(glFormat);
if (!m_cTex) { if (!m_tex) {
m_cTex = makeShared<CTexture>(); m_tex = makeShared<CTexture>();
m_cTex->allocate(); m_tex->allocate();
glBindTexture(GL_TEXTURE_2D, m_cTex->m_iTexID); glBindTexture(GL_TEXTURE_2D, m_tex->m_texID);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
@ -23,24 +23,24 @@ bool CFramebuffer::alloc(int w, int h, uint32_t drmFormat) {
firstAlloc = true; firstAlloc = true;
} }
if (!m_iFbAllocated) { if (!m_fbAllocated) {
glGenFramebuffers(1, &m_iFb); glGenFramebuffers(1, &m_fb);
m_iFbAllocated = true; m_fbAllocated = true;
firstAlloc = true; firstAlloc = true;
} }
if (firstAlloc || m_vSize != Vector2D(w, h)) { if (firstAlloc || m_size != Vector2D(w, h)) {
glBindTexture(GL_TEXTURE_2D, m_cTex->m_iTexID); glBindTexture(GL_TEXTURE_2D, m_tex->m_texID);
glTexImage2D(GL_TEXTURE_2D, 0, glFormat, w, h, 0, GL_RGBA, glType, nullptr); glTexImage2D(GL_TEXTURE_2D, 0, glFormat, w, h, 0, GL_RGBA, glType, nullptr);
glBindFramebuffer(GL_FRAMEBUFFER, m_iFb); glBindFramebuffer(GL_FRAMEBUFFER, m_fb);
glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, m_cTex->m_iTexID, 0); glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, m_tex->m_texID, 0);
// TODO: Allow this with gles2 // TODO: Allow this with gles2
#ifndef GLES2 #ifndef GLES2
if (m_pStencilTex) { if (m_stencilTex) {
glBindTexture(GL_TEXTURE_2D, m_pStencilTex->m_iTexID); glBindTexture(GL_TEXTURE_2D, m_stencilTex->m_texID);
glTexImage2D(GL_TEXTURE_2D, 0, GL_DEPTH24_STENCIL8, w, h, 0, GL_DEPTH_STENCIL, GL_UNSIGNED_INT_24_8, nullptr); glTexImage2D(GL_TEXTURE_2D, 0, GL_DEPTH24_STENCIL8, w, h, 0, GL_DEPTH_STENCIL, GL_UNSIGNED_INT_24_8, nullptr);
glFramebufferTexture2D(GL_FRAMEBUFFER, GL_STENCIL_ATTACHMENT, GL_TEXTURE_2D, m_pStencilTex->m_iTexID, 0); glFramebufferTexture2D(GL_FRAMEBUFFER, GL_STENCIL_ATTACHMENT, GL_TEXTURE_2D, m_stencilTex->m_texID, 0);
} }
#endif #endif
@ -53,7 +53,7 @@ bool CFramebuffer::alloc(int w, int h, uint32_t drmFormat) {
glBindTexture(GL_TEXTURE_2D, 0); glBindTexture(GL_TEXTURE_2D, 0);
glBindFramebuffer(GL_FRAMEBUFFER, 0); glBindFramebuffer(GL_FRAMEBUFFER, 0);
m_vSize = Vector2D(w, h); m_size = Vector2D(w, h);
return true; return true;
} }
@ -61,13 +61,13 @@ bool CFramebuffer::alloc(int w, int h, uint32_t drmFormat) {
void CFramebuffer::addStencil(SP<CTexture> tex) { void CFramebuffer::addStencil(SP<CTexture> tex) {
// TODO: Allow this with gles2 // TODO: Allow this with gles2
#ifndef GLES2 #ifndef GLES2
m_pStencilTex = tex; m_stencilTex = tex;
glBindTexture(GL_TEXTURE_2D, m_pStencilTex->m_iTexID); glBindTexture(GL_TEXTURE_2D, m_stencilTex->m_texID);
glTexImage2D(GL_TEXTURE_2D, 0, GL_DEPTH24_STENCIL8, m_vSize.x, m_vSize.y, 0, GL_DEPTH_STENCIL, GL_UNSIGNED_INT_24_8, nullptr); glTexImage2D(GL_TEXTURE_2D, 0, GL_DEPTH24_STENCIL8, m_size.x, m_size.y, 0, GL_DEPTH_STENCIL, GL_UNSIGNED_INT_24_8, nullptr);
glBindFramebuffer(GL_FRAMEBUFFER, m_iFb); glBindFramebuffer(GL_FRAMEBUFFER, m_fb);
glFramebufferTexture2D(GL_FRAMEBUFFER, GL_STENCIL_ATTACHMENT, GL_TEXTURE_2D, m_pStencilTex->m_iTexID, 0); glFramebufferTexture2D(GL_FRAMEBUFFER, GL_STENCIL_ATTACHMENT, GL_TEXTURE_2D, m_stencilTex->m_texID, 0);
auto status = glCheckFramebufferStatus(GL_FRAMEBUFFER); auto status = glCheckFramebufferStatus(GL_FRAMEBUFFER);
RASSERT((status == GL_FRAMEBUFFER_COMPLETE), "Failed adding a stencil to fbo!", status); RASSERT((status == GL_FRAMEBUFFER_COMPLETE), "Failed adding a stencil to fbo!", status);
@ -79,15 +79,15 @@ void CFramebuffer::addStencil(SP<CTexture> tex) {
void CFramebuffer::bind() { void CFramebuffer::bind() {
#ifndef GLES2 #ifndef GLES2
glBindFramebuffer(GL_DRAW_FRAMEBUFFER, m_iFb); glBindFramebuffer(GL_DRAW_FRAMEBUFFER, m_fb);
#else #else
glBindFramebuffer(GL_FRAMEBUFFER, m_iFb); glBindFramebuffer(GL_FRAMEBUFFER, m_iFb);
#endif #endif
if (g_pHyprOpenGL) if (g_pHyprOpenGL)
glViewport(0, 0, g_pHyprOpenGL->m_RenderData.pMonitor->m_pixelSize.x, g_pHyprOpenGL->m_RenderData.pMonitor->m_pixelSize.y); glViewport(0, 0, g_pHyprOpenGL->m_renderData.pMonitor->m_pixelSize.x, g_pHyprOpenGL->m_renderData.pMonitor->m_pixelSize.y);
else else
glViewport(0, 0, m_vSize.x, m_vSize.y); glViewport(0, 0, m_size.x, m_size.y);
} }
void CFramebuffer::unbind() { void CFramebuffer::unbind() {
@ -99,20 +99,20 @@ void CFramebuffer::unbind() {
} }
void CFramebuffer::release() { void CFramebuffer::release() {
if (m_iFbAllocated) { if (m_fbAllocated) {
glBindFramebuffer(GL_FRAMEBUFFER, m_iFb); glBindFramebuffer(GL_FRAMEBUFFER, m_fb);
glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, 0, 0); glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, 0, 0);
glBindFramebuffer(GL_FRAMEBUFFER, 0); glBindFramebuffer(GL_FRAMEBUFFER, 0);
glDeleteFramebuffers(1, &m_iFb); glDeleteFramebuffers(1, &m_fb);
m_iFbAllocated = false; m_fbAllocated = false;
m_iFb = 0; m_fb = 0;
} }
if (m_cTex) if (m_tex)
m_cTex.reset(); m_tex.reset();
m_vSize = Vector2D(); m_size = Vector2D();
} }
CFramebuffer::~CFramebuffer() { CFramebuffer::~CFramebuffer() {
@ -120,17 +120,17 @@ CFramebuffer::~CFramebuffer() {
} }
bool CFramebuffer::isAllocated() { bool CFramebuffer::isAllocated() {
return m_iFbAllocated && m_cTex; return m_fbAllocated && m_tex;
} }
SP<CTexture> CFramebuffer::getTexture() { SP<CTexture> CFramebuffer::getTexture() {
return m_cTex; return m_tex;
} }
GLuint CFramebuffer::getFBID() { GLuint CFramebuffer::getFBID() {
return m_iFbAllocated ? m_iFb : 0; return m_fbAllocated ? m_fb : 0;
} }
SP<CTexture> CFramebuffer::getStencilTex() { SP<CTexture> CFramebuffer::getStencilTex() {
return m_pStencilTex; return m_stencilTex;
} }

10
src/render/Framebuffer.hpp
View File

@ -19,14 +19,14 @@ class CFramebuffer {
SP<CTexture> getStencilTex(); SP<CTexture> getStencilTex();
GLuint getFBID(); GLuint getFBID();
Vector2D m_vSize; Vector2D m_size;
private: private:
SP<CTexture> m_cTex; SP<CTexture> m_tex;
GLuint m_iFb = -1; GLuint m_fb = -1;
bool m_iFbAllocated = false; bool m_fbAllocated = false;
SP<CTexture> m_pStencilTex; SP<CTexture> m_stencilTex;
friend class CRenderbuffer; friend class CRenderbuffer;
}; };

998
src/render/OpenGL.cpp
View File

File diff suppressed because it is too large Load Diff

65
src/render/OpenGL.hpp
View File

@ -239,24 +239,24 @@ class CHyprOpenGLImpl {
EGLImageKHR createEGLImage(const Aquamarine::SDMABUFAttrs& attrs); EGLImageKHR createEGLImage(const Aquamarine::SDMABUFAttrs& attrs);
bool initShaders(); bool initShaders();
bool m_bShadersInitialized = false; bool m_shadersInitialized = false;
SP<SPreparedShaders> m_shaders; SP<SPreparedShaders> m_shaders;
SCurrentRenderData m_RenderData; SCurrentRenderData m_renderData;
Hyprutils::OS::CFileDescriptor m_iGBMFD; Hyprutils::OS::CFileDescriptor m_gbmFD;
gbm_device* m_pGbmDevice = nullptr; gbm_device* m_gbmDevice = nullptr;
EGLContext m_pEglContext = nullptr; EGLContext m_eglContext = nullptr;
EGLDisplay m_pEglDisplay = nullptr; EGLDisplay m_eglDisplay = nullptr;
EGLDeviceEXT m_pEglDevice = nullptr; EGLDeviceEXT m_eglDevice = nullptr;
uint failedAssetsNo = 0; uint m_failedAssetsNo = 0;
bool m_bReloadScreenShader = true; // at launch it can be set bool m_reloadScreenShader = true; // at launch it can be set
std::map<PHLWINDOWREF, CFramebuffer> m_mWindowFramebuffers; std::map<PHLWINDOWREF, CFramebuffer> m_windowFramebuffers;
std::map<PHLLSREF, CFramebuffer> m_mLayerFramebuffers; std::map<PHLLSREF, CFramebuffer> m_layerFramebuffers;
std::map<PHLMONITORREF, SMonitorRenderData> m_mMonitorRenderResources; std::map<PHLMONITORREF, SMonitorRenderData> m_monitorRenderResources;
std::map<PHLMONITORREF, CFramebuffer> m_mMonitorBGFBs; std::map<PHLMONITORREF, CFramebuffer> m_monitorBGFBs;
struct { struct {
PFNGLEGLIMAGETARGETRENDERBUFFERSTORAGEOESPROC glEGLImageTargetRenderbufferStorageOES = nullptr; PFNGLEGLIMAGETARGETRENDERBUFFERSTORAGEOESPROC glEGLImageTargetRenderbufferStorageOES = nullptr;
@ -274,7 +274,7 @@ class CHyprOpenGLImpl {
PFNEGLDESTROYSYNCKHRPROC eglDestroySyncKHR = nullptr; PFNEGLDESTROYSYNCKHRPROC eglDestroySyncKHR = nullptr;
PFNEGLDUPNATIVEFENCEFDANDROIDPROC eglDupNativeFenceFDANDROID = nullptr; PFNEGLDUPNATIVEFENCEFDANDROIDPROC eglDupNativeFenceFDANDROID = nullptr;
PFNEGLWAITSYNCKHRPROC eglWaitSyncKHR = nullptr; PFNEGLWAITSYNCKHRPROC eglWaitSyncKHR = nullptr;
} m_sProc; } m_proc;
struct { struct {
bool EXT_read_format_bgra = false; bool EXT_read_format_bgra = false;
@ -283,9 +283,9 @@ class CHyprOpenGLImpl {
bool KHR_display_reference = false; bool KHR_display_reference = false;
bool IMG_context_priority = false; bool IMG_context_priority = false;
bool EXT_create_context_robustness = false; bool EXT_create_context_robustness = false;
} m_sExts; } m_exts;
SP<CTexture> m_pScreencopyDeniedTexture; SP<CTexture> m_screencopyDeniedTexture;
private: private:
enum eEGLContextVersion : uint8_t { enum eEGLContextVersion : uint8_t {
@ -296,26 +296,27 @@ class CHyprOpenGLImpl {
eEGLContextVersion m_eglContextVersion = EGL_CONTEXT_GLES_3_2; eEGLContextVersion m_eglContextVersion = EGL_CONTEXT_GLES_3_2;
std::list<GLuint> m_lBuffers; std::vector<SDRMFormat> m_drmFormats;
std::list<GLuint> m_lTextures; bool m_hasModifiers = false;
std::vector<SDRMFormat> drmFormats; int m_drmFD = -1;
bool m_bHasModifiers = false; std::string m_extensions;
int m_iDRMFD = -1; bool m_fakeFrame = false;
std::string m_szExtensions; bool m_endFrame = false;
bool m_applyFinalShader = false;
bool m_blend = false;
bool m_offloadedFramebuffer = false;
bool m_cmSupported = true;
bool m_bFakeFrame = false; CShader m_finalScreenShader;
bool m_bEndFrame = false; CTimer m_globalTimer;
bool m_bApplyFinalShader = false;
bool m_bBlend = false;
bool m_bOffloadedFramebuffer = false;
bool m_bCMSupported = true;
CShader m_sFinalScreenShader; SP<CTexture> m_missingAssetTexture;
CTimer m_tGlobalTimer; SP<CTexture> m_backgroundTexture;
SP<CTexture> m_lockDeadTexture;
SP<CTexture> m_pMissingAssetTexture, m_pBackgroundTexture, m_pLockDeadTexture, m_pLockDead2Texture, m_pLockTtyTextTexture; // TODO: don't always load lock SP<CTexture> m_lockDead2Texture;
SP<CTexture> m_lockTtyTextTexture; // TODO: don't always load lock
void logShaderError(const GLuint&, bool program = false, bool silent = false); void logShaderError(const GLuint&, bool program = false, bool silent = false);
GLuint createProgram(const std::string&, const std::string&, bool dynamic = false, bool silent = false); GLuint createProgram(const std::string&, const std::string&, bool dynamic = false, bool silent = false);

44
src/render/Renderbuffer.cpp
View File

@ -15,62 +15,62 @@ CRenderbuffer::~CRenderbuffer() {
g_pHyprRenderer->makeEGLCurrent(); g_pHyprRenderer->makeEGLCurrent();
unbind(); unbind();
m_sFramebuffer.release(); m_framebuffer.release();
glDeleteRenderbuffers(1, &m_iRBO); glDeleteRenderbuffers(1, &m_rbo);
g_pHyprOpenGL->m_sProc.eglDestroyImageKHR(g_pHyprOpenGL->m_pEglDisplay, m_iImage); g_pHyprOpenGL->m_proc.eglDestroyImageKHR(g_pHyprOpenGL->m_eglDisplay, m_image);
} }
CRenderbuffer::CRenderbuffer(SP<Aquamarine::IBuffer> buffer, uint32_t format) : m_pHLBuffer(buffer), m_uDrmFormat(format) { CRenderbuffer::CRenderbuffer(SP<Aquamarine::IBuffer> buffer, uint32_t format) : m_hlBuffer(buffer), m_drmFormat(format) {
auto dma = buffer->dmabuf(); auto dma = buffer->dmabuf();
m_iImage = g_pHyprOpenGL->createEGLImage(dma); m_image = g_pHyprOpenGL->createEGLImage(dma);
if (m_iImage == EGL_NO_IMAGE_KHR) { if (m_image == EGL_NO_IMAGE_KHR) {
Debug::log(ERR, "rb: createEGLImage failed"); Debug::log(ERR, "rb: createEGLImage failed");
return; return;
} }
glGenRenderbuffers(1, &m_iRBO); glGenRenderbuffers(1, &m_rbo);
glBindRenderbuffer(GL_RENDERBUFFER, m_iRBO); glBindRenderbuffer(GL_RENDERBUFFER, m_rbo);
g_pHyprOpenGL->m_sProc.glEGLImageTargetRenderbufferStorageOES(GL_RENDERBUFFER, (GLeglImageOES)m_iImage); g_pHyprOpenGL->m_proc.glEGLImageTargetRenderbufferStorageOES(GL_RENDERBUFFER, (GLeglImageOES)m_image);
glBindRenderbuffer(GL_RENDERBUFFER, 0); glBindRenderbuffer(GL_RENDERBUFFER, 0);
glGenFramebuffers(1, &m_sFramebuffer.m_iFb); glGenFramebuffers(1, &m_framebuffer.m_fb);
m_sFramebuffer.m_iFbAllocated = true; m_framebuffer.m_fbAllocated = true;
m_sFramebuffer.m_vSize = buffer->size; m_framebuffer.m_size = buffer->size;
m_sFramebuffer.bind(); m_framebuffer.bind();
glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_RENDERBUFFER, m_iRBO); glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_RENDERBUFFER, m_rbo);
if (glCheckFramebufferStatus(GL_FRAMEBUFFER) != GL_FRAMEBUFFER_COMPLETE) { if (glCheckFramebufferStatus(GL_FRAMEBUFFER) != GL_FRAMEBUFFER_COMPLETE) {
Debug::log(ERR, "rbo: glCheckFramebufferStatus failed"); Debug::log(ERR, "rbo: glCheckFramebufferStatus failed");
return; return;
} }
m_sFramebuffer.unbind(); m_framebuffer.unbind();
listeners.destroyBuffer = buffer->events.destroy.registerListener([this](std::any d) { g_pHyprRenderer->onRenderbufferDestroy(this); }); m_listeners.destroyBuffer = buffer->events.destroy.registerListener([this](std::any d) { g_pHyprRenderer->onRenderbufferDestroy(this); });
m_bGood = true; m_good = true;
} }
bool CRenderbuffer::good() { bool CRenderbuffer::good() {
return m_bGood; return m_good;
} }
void CRenderbuffer::bind() { void CRenderbuffer::bind() {
glBindRenderbuffer(GL_RENDERBUFFER, m_iRBO); glBindRenderbuffer(GL_RENDERBUFFER, m_rbo);
bindFB(); bindFB();
} }
void CRenderbuffer::bindFB() { void CRenderbuffer::bindFB() {
m_sFramebuffer.bind(); m_framebuffer.bind();
} }
void CRenderbuffer::unbind() { void CRenderbuffer::unbind() {
glBindRenderbuffer(GL_RENDERBUFFER, 0); glBindRenderbuffer(GL_RENDERBUFFER, 0);
m_sFramebuffer.unbind(); m_framebuffer.unbind();
} }
CFramebuffer* CRenderbuffer::getFB() { CFramebuffer* CRenderbuffer::getFB() {
return &m_sFramebuffer; return &m_framebuffer;
} }

14
src/render/Renderbuffer.hpp
View File

@ -19,16 +19,16 @@ class CRenderbuffer {
CFramebuffer* getFB(); CFramebuffer* getFB();
uint32_t getFormat(); uint32_t getFormat();
WP<Aquamarine::IBuffer> m_pHLBuffer; WP<Aquamarine::IBuffer> m_hlBuffer;
private: private:
void* m_iImage = nullptr; void* m_image = nullptr;
GLuint m_iRBO = 0; GLuint m_rbo = 0;
CFramebuffer m_sFramebuffer; CFramebuffer m_framebuffer;
uint32_t m_uDrmFormat = 0; uint32_t m_drmFormat = 0;
bool m_bGood = false; bool m_good = false;
struct { struct {
CHyprSignalListener destroyBuffer; CHyprSignalListener destroyBuffer;
} listeners; } m_listeners;
}; };

321
src/render/Renderer.cpp
View File

@ -48,7 +48,7 @@ extern "C" {
static int cursorTicker(void* data) { static int cursorTicker(void* data) {
g_pHyprRenderer->ensureCursorRenderingMode(); g_pHyprRenderer->ensureCursorRenderingMode();
wl_event_source_timer_update(g_pHyprRenderer->m_pCursorTicker, 500); wl_event_source_timer_update(g_pHyprRenderer->m_cursorTicker, 500);
return 0; return 0;
} }
@ -62,7 +62,7 @@ CHyprRenderer::CHyprRenderer() {
std::transform(name.begin(), name.end(), name.begin(), tolower); std::transform(name.begin(), name.end(), name.begin(), tolower);
if (name.contains("nvidia")) if (name.contains("nvidia"))
m_bNvidia = true; m_nvidia = true;
Debug::log(LOG, "DRM driver information: {} v{}.{}.{} from {} description {}", name, DRMV->version_major, DRMV->version_minor, DRMV->version_patchlevel, Debug::log(LOG, "DRM driver information: {} v{}.{}.{} from {} description {}", name, DRMV->version_major, DRMV->version_minor, DRMV->version_patchlevel,
std::string{DRMV->date, DRMV->date_len}, std::string{DRMV->desc, DRMV->desc_len}); std::string{DRMV->date, DRMV->date_len}, std::string{DRMV->desc, DRMV->desc_len});
@ -79,7 +79,7 @@ CHyprRenderer::CHyprRenderer() {
std::transform(name.begin(), name.end(), name.begin(), tolower); std::transform(name.begin(), name.end(), name.begin(), tolower);
if (name.contains("nvidia")) if (name.contains("nvidia"))
m_bNvidia = true; m_nvidia = true;
Debug::log(LOG, "Primary DRM driver information: {} v{}.{}.{} from {} description {}", name, DRMV->version_major, DRMV->version_minor, DRMV->version_patchlevel, Debug::log(LOG, "Primary DRM driver information: {} v{}.{}.{} from {} description {}", name, DRMV->version_major, DRMV->version_minor, DRMV->version_patchlevel,
std::string{DRMV->date, DRMV->date_len}, std::string{DRMV->desc, DRMV->desc_len}); std::string{DRMV->date, DRMV->date_len}, std::string{DRMV->desc, DRMV->desc_len});
@ -90,27 +90,26 @@ CHyprRenderer::CHyprRenderer() {
drmFreeVersion(DRMV); drmFreeVersion(DRMV);
} }
if (m_bNvidia) if (m_nvidia)
Debug::log(WARN, "NVIDIA detected, please remember to follow nvidia instructions on the wiki"); Debug::log(WARN, "NVIDIA detected, please remember to follow nvidia instructions on the wiki");
// cursor hiding stuff // cursor hiding stuff
static auto P = g_pHookSystem->hookDynamic("keyPress", [&](void* self, SCallbackInfo& info, std::any param) { static auto P = g_pHookSystem->hookDynamic("keyPress", [&](void* self, SCallbackInfo& info, std::any param) {
if (m_sCursorHiddenConditions.hiddenOnKeyboard) if (m_cursorHiddenConditions.hiddenOnKeyboard)
return; return;
m_sCursorHiddenConditions.hiddenOnKeyboard = true; m_cursorHiddenConditions.hiddenOnKeyboard = true;
ensureCursorRenderingMode(); ensureCursorRenderingMode();
}); });
static auto P2 = g_pHookSystem->hookDynamic("mouseMove", [&](void* self, SCallbackInfo& info, std::any param) { static auto P2 = g_pHookSystem->hookDynamic("mouseMove", [&](void* self, SCallbackInfo& info, std::any param) {
if (!m_sCursorHiddenConditions.hiddenOnKeyboard && m_sCursorHiddenConditions.hiddenOnTouch == g_pInputManager->m_lastInputTouch && if (!m_cursorHiddenConditions.hiddenOnKeyboard && m_cursorHiddenConditions.hiddenOnTouch == g_pInputManager->m_lastInputTouch && !m_cursorHiddenConditions.hiddenOnTimeout)
!m_sCursorHiddenConditions.hiddenOnTimeout)
return; return;
m_sCursorHiddenConditions.hiddenOnKeyboard = false; m_cursorHiddenConditions.hiddenOnKeyboard = false;
m_sCursorHiddenConditions.hiddenOnTimeout = false; m_cursorHiddenConditions.hiddenOnTimeout = false;
m_sCursorHiddenConditions.hiddenOnTouch = g_pInputManager->m_lastInputTouch; m_cursorHiddenConditions.hiddenOnTouch = g_pInputManager->m_lastInputTouch;
ensureCursorRenderingMode(); ensureCursorRenderingMode();
}); });
@ -124,19 +123,19 @@ CHyprRenderer::CHyprRenderer() {
}); });
}); });
m_pCursorTicker = wl_event_loop_add_timer(g_pCompositor->m_wlEventLoop, cursorTicker, nullptr); m_cursorTicker = wl_event_loop_add_timer(g_pCompositor->m_wlEventLoop, cursorTicker, nullptr);
wl_event_source_timer_update(m_pCursorTicker, 500); wl_event_source_timer_update(m_cursorTicker, 500);
m_tRenderUnfocusedTimer = makeShared<CEventLoopTimer>( m_renderUnfocusedTimer = makeShared<CEventLoopTimer>(
std::nullopt, std::nullopt,
[this](SP<CEventLoopTimer> self, void* data) { [this](SP<CEventLoopTimer> self, void* data) {
static auto PFPS = CConfigValue<Hyprlang::INT>("misc:render_unfocused_fps"); static auto PFPS = CConfigValue<Hyprlang::INT>("misc:render_unfocused_fps");
if (m_vRenderUnfocused.empty()) if (m_renderUnfocused.empty())
return; return;
bool dirty = false; bool dirty = false;
for (auto& w : m_vRenderUnfocused) { for (auto& w : m_renderUnfocused) {
if (!w) { if (!w) {
dirty = true; dirty = true;
continue; continue;
@ -153,19 +152,19 @@ CHyprRenderer::CHyprRenderer() {
} }
if (dirty) if (dirty)
std::erase_if(m_vRenderUnfocused, [](const auto& e) { return !e || !e->m_windowData.renderUnfocused.valueOr(false); }); std::erase_if(m_renderUnfocused, [](const auto& e) { return !e || !e->m_windowData.renderUnfocused.valueOr(false); });
if (!m_vRenderUnfocused.empty()) if (!m_renderUnfocused.empty())
m_tRenderUnfocusedTimer->updateTimeout(std::chrono::milliseconds(1000 / *PFPS)); m_renderUnfocusedTimer->updateTimeout(std::chrono::milliseconds(1000 / *PFPS));
}, },
nullptr); nullptr);
g_pEventLoopManager->addTimer(m_tRenderUnfocusedTimer); g_pEventLoopManager->addTimer(m_renderUnfocusedTimer);
} }
CHyprRenderer::~CHyprRenderer() { CHyprRenderer::~CHyprRenderer() {
if (m_pCursorTicker) if (m_cursorTicker)
wl_event_source_remove(m_pCursorTicker); wl_event_source_remove(m_cursorTicker);
} }
bool CHyprRenderer::shouldRenderWindow(PHLWINDOW pWindow, PHLMONITOR pMonitor) { bool CHyprRenderer::shouldRenderWindow(PHLWINDOW pWindow, PHLMONITOR pMonitor) {
@ -521,11 +520,11 @@ void CHyprRenderer::renderWindow(PHLWINDOW pWindow, PHLMONITOR pMonitor, const T
EMIT_HOOK_EVENT("render", RENDER_PRE_WINDOW); EMIT_HOOK_EVENT("render", RENDER_PRE_WINDOW);
if (*PDIMAROUND && pWindow->m_windowData.dimAround.valueOrDefault() && !m_bRenderingSnapshot && mode != RENDER_PASS_POPUP) { if (*PDIMAROUND && pWindow->m_windowData.dimAround.valueOrDefault() && !m_bRenderingSnapshot && mode != RENDER_PASS_POPUP) {
CBox monbox = {0, 0, g_pHyprOpenGL->m_RenderData.pMonitor->m_transformedSize.x, g_pHyprOpenGL->m_RenderData.pMonitor->m_transformedSize.y}; CBox monbox = {0, 0, g_pHyprOpenGL->m_renderData.pMonitor->m_transformedSize.x, g_pHyprOpenGL->m_renderData.pMonitor->m_transformedSize.y};
CRectPassElement::SRectData data; CRectPassElement::SRectData data;
data.color = CHyprColor(0, 0, 0, *PDIMAROUND * renderdata.alpha * renderdata.fadeAlpha); data.color = CHyprColor(0, 0, 0, *PDIMAROUND * renderdata.alpha * renderdata.fadeAlpha);
data.box = monbox; data.box = monbox;
m_sRenderPass.add(makeShared<CRectPassElement>(data)); m_renderPass.add(makeShared<CRectPassElement>(data));
} }
renderdata.pos.x += pWindow->m_floatingOffset.x; renderdata.pos.x += pWindow->m_floatingOffset.x;
@ -581,7 +580,7 @@ void CHyprRenderer::renderWindow(PHLWINDOW pWindow, PHLMONITOR pMonitor, const T
data.blur = true; data.blur = true;
data.blurA = renderdata.fadeAlpha; data.blurA = renderdata.fadeAlpha;
data.xray = g_pHyprOpenGL->shouldUseNewBlurOptimizations(nullptr, pWindow); data.xray = g_pHyprOpenGL->shouldUseNewBlurOptimizations(nullptr, pWindow);
m_sRenderPass.add(makeShared<CRectPassElement>(data)); m_renderPass.add(makeShared<CRectPassElement>(data));
renderdata.blur = false; renderdata.blur = false;
} }
@ -592,7 +591,7 @@ void CHyprRenderer::renderWindow(PHLWINDOW pWindow, PHLMONITOR pMonitor, const T
renderdata.texture = s->m_current.texture; renderdata.texture = s->m_current.texture;
renderdata.surface = s; renderdata.surface = s;
renderdata.mainSurface = s == pWindow->m_wlSurface->resource(); renderdata.mainSurface = s == pWindow->m_wlSurface->resource();
m_sRenderPass.add(makeShared<CSurfacePassElement>(renderdata)); m_renderPass.add(makeShared<CSurfacePassElement>(renderdata));
renderdata.surfaceCounter++; renderdata.surfaceCounter++;
}, },
nullptr); nullptr);
@ -609,7 +608,7 @@ void CHyprRenderer::renderWindow(PHLWINDOW pWindow, PHLMONITOR pMonitor, const T
} }
if (TRANSFORMERSPRESENT) { if (TRANSFORMERSPRESENT) {
CFramebuffer* last = g_pHyprOpenGL->m_RenderData.currentFB; CFramebuffer* last = g_pHyprOpenGL->m_renderData.currentFB;
for (auto const& t : pWindow->m_transformers) { for (auto const& t : pWindow->m_transformers) {
last = t->transform(last); last = t->transform(last);
} }
@ -619,7 +618,7 @@ void CHyprRenderer::renderWindow(PHLWINDOW pWindow, PHLMONITOR pMonitor, const T
} }
} }
g_pHyprOpenGL->m_RenderData.clipBox = CBox(); g_pHyprOpenGL->m_renderData.clipBox = CBox();
if (mode == RENDER_PASS_ALL || mode == RENDER_PASS_POPUP) { if (mode == RENDER_PASS_ALL || mode == RENDER_PASS_POPUP) {
if (!pWindow->m_isX11) { if (!pWindow->m_isX11) {
@ -660,7 +659,7 @@ void CHyprRenderer::renderWindow(PHLWINDOW pWindow, PHLMONITOR pMonitor, const T
renderdata.texture = s->m_current.texture; renderdata.texture = s->m_current.texture;
renderdata.surface = s; renderdata.surface = s;
renderdata.mainSurface = false; renderdata.mainSurface = false;
m_sRenderPass.add(makeShared<CSurfacePassElement>(renderdata)); m_renderPass.add(makeShared<CSurfacePassElement>(renderdata));
renderdata.surfaceCounter++; renderdata.surfaceCounter++;
}, },
data); data);
@ -681,11 +680,11 @@ void CHyprRenderer::renderWindow(PHLWINDOW pWindow, PHLMONITOR pMonitor, const T
} }
// for plugins // for plugins
g_pHyprOpenGL->m_RenderData.currentWindow = pWindow; g_pHyprOpenGL->m_renderData.currentWindow = pWindow;
EMIT_HOOK_EVENT("render", RENDER_POST_WINDOW); EMIT_HOOK_EVENT("render", RENDER_POST_WINDOW);
g_pHyprOpenGL->m_RenderData.currentWindow.reset(); g_pHyprOpenGL->m_renderData.currentWindow.reset();
} }
void CHyprRenderer::renderLayer(PHLLS pLayer, PHLMONITOR pMonitor, const Time::steady_tp& time, bool popups, bool lockscreen) { void CHyprRenderer::renderLayer(PHLLS pLayer, PHLMONITOR pMonitor, const Time::steady_tp& time, bool popups, bool lockscreen) {
@ -700,9 +699,9 @@ void CHyprRenderer::renderLayer(PHLLS pLayer, PHLMONITOR pMonitor, const Time::s
if (*PDIMAROUND && pLayer->m_dimAround && !m_bRenderingSnapshot && !popups) { if (*PDIMAROUND && pLayer->m_dimAround && !m_bRenderingSnapshot && !popups) {
CRectPassElement::SRectData data; CRectPassElement::SRectData data;
data.box = {0, 0, g_pHyprOpenGL->m_RenderData.pMonitor->m_transformedSize.x, g_pHyprOpenGL->m_RenderData.pMonitor->m_transformedSize.y}; data.box = {0, 0, g_pHyprOpenGL->m_renderData.pMonitor->m_transformedSize.x, g_pHyprOpenGL->m_renderData.pMonitor->m_transformedSize.y};
data.color = CHyprColor(0, 0, 0, *PDIMAROUND * pLayer->m_alpha->value()); data.color = CHyprColor(0, 0, 0, *PDIMAROUND * pLayer->m_alpha->value());
m_sRenderPass.add(makeShared<CRectPassElement>(data)); m_renderPass.add(makeShared<CRectPassElement>(data));
} }
if (pLayer->m_fadingOut) { if (pLayer->m_fadingOut) {
@ -742,7 +741,7 @@ void CHyprRenderer::renderLayer(PHLLS pLayer, PHLMONITOR pMonitor, const Time::s
renderdata.texture = s->m_current.texture; renderdata.texture = s->m_current.texture;
renderdata.surface = s; renderdata.surface = s;
renderdata.mainSurface = s == pLayer->m_surface->resource(); renderdata.mainSurface = s == pLayer->m_surface->resource();
m_sRenderPass.add(makeShared<CSurfacePassElement>(renderdata)); m_renderPass.add(makeShared<CSurfacePassElement>(renderdata));
renderdata.surfaceCounter++; renderdata.surfaceCounter++;
}, },
&renderdata); &renderdata);
@ -763,7 +762,7 @@ void CHyprRenderer::renderLayer(PHLLS pLayer, PHLMONITOR pMonitor, const Time::s
renderdata.texture = popup->m_wlSurface->resource()->m_current.texture; renderdata.texture = popup->m_wlSurface->resource()->m_current.texture;
renderdata.surface = popup->m_wlSurface->resource(); renderdata.surface = popup->m_wlSurface->resource();
renderdata.mainSurface = false; renderdata.mainSurface = false;
m_sRenderPass.add(makeShared<CSurfacePassElement>(renderdata)); m_renderPass.add(makeShared<CSurfacePassElement>(renderdata));
renderdata.surfaceCounter++; renderdata.surfaceCounter++;
}, },
&renderdata); &renderdata);
@ -798,7 +797,7 @@ void CHyprRenderer::renderIMEPopup(CInputPopup* pPopup, PHLMONITOR pMonitor, con
renderdata.texture = s->m_current.texture; renderdata.texture = s->m_current.texture;
renderdata.surface = s; renderdata.surface = s;
renderdata.mainSurface = s == SURF; renderdata.mainSurface = s == SURF;
m_sRenderPass.add(makeShared<CSurfacePassElement>(renderdata)); m_renderPass.add(makeShared<CSurfacePassElement>(renderdata));
renderdata.surfaceCounter++; renderdata.surfaceCounter++;
}, },
&renderdata); &renderdata);
@ -819,7 +818,7 @@ void CHyprRenderer::renderSessionLockSurface(WP<SSessionLockSurface> pSurface, P
renderdata.texture = s->m_current.texture; renderdata.texture = s->m_current.texture;
renderdata.surface = s; renderdata.surface = s;
renderdata.mainSurface = s == pSurface->surface->surface(); renderdata.mainSurface = s == pSurface->surface->surface();
m_sRenderPass.add(makeShared<CSurfacePassElement>(renderdata)); m_renderPass.add(makeShared<CSurfacePassElement>(renderdata));
renderdata.surfaceCounter++; renderdata.surfaceCounter++;
}, },
&renderdata); &renderdata);
@ -853,12 +852,12 @@ void CHyprRenderer::renderAllClientsForWorkspace(PHLMONITOR pMonitor, PHLWORKSPA
RENDERMODIFDATA.modifs.emplace_back(std::make_pair<>(SRenderModifData::eRenderModifType::RMOD_TYPE_SCALE, scale)); RENDERMODIFDATA.modifs.emplace_back(std::make_pair<>(SRenderModifData::eRenderModifType::RMOD_TYPE_SCALE, scale));
if (!RENDERMODIFDATA.modifs.empty()) { if (!RENDERMODIFDATA.modifs.empty()) {
g_pHyprRenderer->m_sRenderPass.add(makeShared<CRendererHintsPassElement>(CRendererHintsPassElement::SData{RENDERMODIFDATA})); g_pHyprRenderer->m_renderPass.add(makeShared<CRendererHintsPassElement>(CRendererHintsPassElement::SData{RENDERMODIFDATA}));
} }
CScopeGuard x([&RENDERMODIFDATA] { CScopeGuard x([&RENDERMODIFDATA] {
if (!RENDERMODIFDATA.modifs.empty()) { if (!RENDERMODIFDATA.modifs.empty()) {
g_pHyprRenderer->m_sRenderPass.add(makeShared<CRendererHintsPassElement>(CRendererHintsPassElement::SData{SRenderModifData{}})); g_pHyprRenderer->m_renderPass.add(makeShared<CRendererHintsPassElement>(CRendererHintsPassElement::SData{SRenderModifData{}}));
} }
}); });
@ -866,7 +865,7 @@ void CHyprRenderer::renderAllClientsForWorkspace(PHLMONITOR pMonitor, PHLWORKSPA
// allow rendering without a workspace. In this case, just render layers. // allow rendering without a workspace. In this case, just render layers.
if (*PRENDERTEX /* inverted cfg flag */) if (*PRENDERTEX /* inverted cfg flag */)
m_sRenderPass.add(makeShared<CClearPassElement>(CClearPassElement::SClearData{CHyprColor(*PBACKGROUNDCOLOR)})); m_renderPass.add(makeShared<CClearPassElement>(CClearPassElement::SClearData{CHyprColor(*PBACKGROUNDCOLOR)}));
else else
g_pHyprOpenGL->clearWithTex(); // will apply the hypr "wallpaper" g_pHyprOpenGL->clearWithTex(); // will apply the hypr "wallpaper"
@ -888,7 +887,7 @@ void CHyprRenderer::renderAllClientsForWorkspace(PHLMONITOR pMonitor, PHLWORKSPA
if (!*PXPMODE) { if (!*PXPMODE) {
if (*PRENDERTEX /* inverted cfg flag */) if (*PRENDERTEX /* inverted cfg flag */)
m_sRenderPass.add(makeShared<CClearPassElement>(CClearPassElement::SClearData{CHyprColor(*PBACKGROUNDCOLOR)})); m_renderPass.add(makeShared<CClearPassElement>(CClearPassElement::SClearData{CHyprColor(*PBACKGROUNDCOLOR)}));
else else
g_pHyprOpenGL->clearWithTex(); // will apply the hypr "wallpaper" g_pHyprOpenGL->clearWithTex(); // will apply the hypr "wallpaper"
@ -919,7 +918,7 @@ void CHyprRenderer::renderAllClientsForWorkspace(PHLMONITOR pMonitor, PHLWORKSPA
data.box = {translate.x, translate.y, pMonitor->m_transformedSize.x * scale, pMonitor->m_transformedSize.y * scale}; 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)); data.color = CHyprColor(0, 0, 0, *PDIMSPECIAL * (ANIMOUT ? (1.0 - SPECIALANIMPROGRS) : SPECIALANIMPROGRS));
g_pHyprRenderer->m_sRenderPass.add(makeShared<CRectPassElement>(data)); g_pHyprRenderer->m_renderPass.add(makeShared<CRectPassElement>(data));
} }
if (*PBLURSPECIAL && *PBLUR) { if (*PBLURSPECIAL && *PBLUR) {
@ -929,7 +928,7 @@ void CHyprRenderer::renderAllClientsForWorkspace(PHLMONITOR pMonitor, PHLWORKSPA
data.blur = true; data.blur = true;
data.blurA = (ANIMOUT ? (1.0 - SPECIALANIMPROGRS) : SPECIALANIMPROGRS); data.blurA = (ANIMOUT ? (1.0 - SPECIALANIMPROGRS) : SPECIALANIMPROGRS);
g_pHyprRenderer->m_sRenderPass.add(makeShared<CRectPassElement>(data)); g_pHyprRenderer->m_renderPass.add(makeShared<CRectPassElement>(data));
} }
break; break;
@ -1027,15 +1026,15 @@ void CHyprRenderer::renderSessionLockMissing(PHLMONITOR pMonitor) {
if (ANY_PRESENT) { if (ANY_PRESENT) {
// render image2, without instructions. Lock still "alive", unless texture dead // render image2, without instructions. Lock still "alive", unless texture dead
g_pHyprOpenGL->renderTexture(g_pHyprOpenGL->m_pLockDead2Texture, monbox, ALPHA); g_pHyprOpenGL->renderTexture(g_pHyprOpenGL->m_lockDead2Texture, monbox, ALPHA);
} else { } else {
// render image, with instructions. Lock is gone. // render image, with instructions. Lock is gone.
g_pHyprOpenGL->renderTexture(g_pHyprOpenGL->m_pLockDeadTexture, monbox, ALPHA); g_pHyprOpenGL->renderTexture(g_pHyprOpenGL->m_lockDeadTexture, monbox, ALPHA);
// also render text for the tty number // also render text for the tty number
if (g_pHyprOpenGL->m_pLockTtyTextTexture) { if (g_pHyprOpenGL->m_lockTtyTextTexture) {
CBox texbox = {{}, g_pHyprOpenGL->m_pLockTtyTextTexture->m_vSize}; CBox texbox = {{}, g_pHyprOpenGL->m_lockTtyTextTexture->m_size};
g_pHyprOpenGL->renderTexture(g_pHyprOpenGL->m_pLockTtyTextTexture, texbox, 1.F); g_pHyprOpenGL->renderTexture(g_pHyprOpenGL->m_lockTtyTextTexture, texbox, 1.F);
} }
} }
@ -1096,13 +1095,13 @@ void CHyprRenderer::calculateUVForSurface(PHLWINDOW pWindow, SP<CWLSurfaceResour
} }
} }
g_pHyprOpenGL->m_RenderData.primarySurfaceUVTopLeft = uvTL; g_pHyprOpenGL->m_renderData.primarySurfaceUVTopLeft = uvTL;
g_pHyprOpenGL->m_RenderData.primarySurfaceUVBottomRight = uvBR; g_pHyprOpenGL->m_renderData.primarySurfaceUVBottomRight = uvBR;
if (g_pHyprOpenGL->m_RenderData.primarySurfaceUVTopLeft == Vector2D() && g_pHyprOpenGL->m_RenderData.primarySurfaceUVBottomRight == Vector2D(1, 1)) { if (g_pHyprOpenGL->m_renderData.primarySurfaceUVTopLeft == Vector2D() && g_pHyprOpenGL->m_renderData.primarySurfaceUVBottomRight == Vector2D(1, 1)) {
// No special UV mods needed // No special UV mods needed
g_pHyprOpenGL->m_RenderData.primarySurfaceUVTopLeft = Vector2D(-1, -1); g_pHyprOpenGL->m_renderData.primarySurfaceUVTopLeft = Vector2D(-1, -1);
g_pHyprOpenGL->m_RenderData.primarySurfaceUVBottomRight = Vector2D(-1, -1); g_pHyprOpenGL->m_renderData.primarySurfaceUVBottomRight = Vector2D(-1, -1);
} }
if (!main || !pWindow) if (!main || !pWindow)
@ -1132,17 +1131,17 @@ void CHyprRenderer::calculateUVForSurface(PHLWINDOW pWindow, SP<CWLSurfaceResour
uvBR.y = uvBR.y * (maxSize.y / geom.height); uvBR.y = uvBR.y * (maxSize.y / geom.height);
} }
g_pHyprOpenGL->m_RenderData.primarySurfaceUVTopLeft = uvTL; g_pHyprOpenGL->m_renderData.primarySurfaceUVTopLeft = uvTL;
g_pHyprOpenGL->m_RenderData.primarySurfaceUVBottomRight = uvBR; g_pHyprOpenGL->m_renderData.primarySurfaceUVBottomRight = uvBR;
if (g_pHyprOpenGL->m_RenderData.primarySurfaceUVTopLeft == Vector2D() && g_pHyprOpenGL->m_RenderData.primarySurfaceUVBottomRight == Vector2D(1, 1)) { if (g_pHyprOpenGL->m_renderData.primarySurfaceUVTopLeft == Vector2D() && g_pHyprOpenGL->m_renderData.primarySurfaceUVBottomRight == Vector2D(1, 1)) {
// No special UV mods needed // No special UV mods needed
g_pHyprOpenGL->m_RenderData.primarySurfaceUVTopLeft = Vector2D(-1, -1); g_pHyprOpenGL->m_renderData.primarySurfaceUVTopLeft = Vector2D(-1, -1);
g_pHyprOpenGL->m_RenderData.primarySurfaceUVBottomRight = Vector2D(-1, -1); g_pHyprOpenGL->m_renderData.primarySurfaceUVBottomRight = Vector2D(-1, -1);
} }
} else { } else {
g_pHyprOpenGL->m_RenderData.primarySurfaceUVTopLeft = Vector2D(-1, -1); g_pHyprOpenGL->m_renderData.primarySurfaceUVTopLeft = Vector2D(-1, -1);
g_pHyprOpenGL->m_RenderData.primarySurfaceUVBottomRight = Vector2D(-1, -1); g_pHyprOpenGL->m_renderData.primarySurfaceUVBottomRight = Vector2D(-1, -1);
} }
} }
@ -1173,15 +1172,15 @@ void CHyprRenderer::renderMonitor(PHLMONITOR pMonitor) {
if (firstLaunch) { if (firstLaunch) {
firstLaunch = false; firstLaunch = false;
m_tRenderTimer.reset(); m_renderTimer.reset();
} }
if (m_tRenderTimer.getSeconds() < 1.5f && firstLaunchAnimActive) { // TODO: make the animation system more damage-flexible so that this can be migrated to there if (m_renderTimer.getSeconds() < 1.5f && firstLaunchAnimActive) { // TODO: make the animation system more damage-flexible so that this can be migrated to there
if (!*PANIMENABLED) { if (!*PANIMENABLED) {
zoomInFactorFirstLaunch = 1.f; zoomInFactorFirstLaunch = 1.f;
firstLaunchAnimActive = false; firstLaunchAnimActive = false;
} else { } else {
zoomInFactorFirstLaunch = 2.f - g_pAnimationManager->getBezier("default")->getYForPoint(m_tRenderTimer.getSeconds() / 1.5); zoomInFactorFirstLaunch = 2.f - g_pAnimationManager->getBezier("default")->getYForPoint(m_renderTimer.getSeconds() / 1.5);
damageMonitor(pMonitor); damageMonitor(pMonitor);
} }
} else { } else {
@ -1196,7 +1195,7 @@ void CHyprRenderer::renderMonitor(PHLMONITOR pMonitor) {
if (!g_pCompositor->m_sessionActive) if (!g_pCompositor->m_sessionActive)
return; return;
if (pMonitor->m_id == m_pMostHzMonitor->m_id || if (pMonitor->m_id == m_mostHzMonitor->m_id ||
*PVFR == 1) { // unfortunately with VFR we don't have the guarantee mostHz is going to be updated all the time, so we have to ignore that *PVFR == 1) { // unfortunately with VFR we don't have the guarantee mostHz is going to be updated all the time, so we have to ignore that
g_pCompositor->sanityCheckWorkspaces(); g_pCompositor->sanityCheckWorkspaces();
@ -1224,7 +1223,7 @@ void CHyprRenderer::renderMonitor(PHLMONITOR pMonitor) {
return; return;
} }
if (g_pHyprOpenGL->m_RenderData.mouseZoomFactor != 1.0) { if (g_pHyprOpenGL->m_renderData.mouseZoomFactor != 1.0) {
Debug::log(WARN, "Tearing commit requested but scale factor is not 1, ignoring"); Debug::log(WARN, "Tearing commit requested but scale factor is not 1, ignoring");
return; return;
} }
@ -1295,14 +1294,14 @@ void CHyprRenderer::renderMonitor(PHLMONITOR pMonitor) {
} }
if (pMonitor == g_pCompositor->getMonitorFromCursor()) if (pMonitor == g_pCompositor->getMonitorFromCursor())
g_pHyprOpenGL->m_RenderData.mouseZoomFactor = std::clamp(*PZOOMFACTOR, 1.f, INFINITY); g_pHyprOpenGL->m_renderData.mouseZoomFactor = std::clamp(*PZOOMFACTOR, 1.f, INFINITY);
else else
g_pHyprOpenGL->m_RenderData.mouseZoomFactor = 1.f; g_pHyprOpenGL->m_renderData.mouseZoomFactor = 1.f;
if (zoomInFactorFirstLaunch > 1.f) { if (zoomInFactorFirstLaunch > 1.f) {
g_pHyprOpenGL->m_RenderData.mouseZoomFactor = zoomInFactorFirstLaunch; g_pHyprOpenGL->m_renderData.mouseZoomFactor = zoomInFactorFirstLaunch;
g_pHyprOpenGL->m_RenderData.mouseZoomUseMouse = false; g_pHyprOpenGL->m_renderData.mouseZoomUseMouse = false;
g_pHyprOpenGL->m_RenderData.useNearestNeighbor = false; g_pHyprOpenGL->m_renderData.useNearestNeighbor = false;
pMonitor->m_forceFullFrames = 10; pMonitor->m_forceFullFrames = 10;
} }
@ -1361,7 +1360,7 @@ void CHyprRenderer::renderMonitor(PHLMONITOR pMonitor) {
CRectPassElement::SRectData data; CRectPassElement::SRectData data;
data.box = {0, 0, pMonitor->m_transformedSize.x, pMonitor->m_transformedSize.y}; data.box = {0, 0, pMonitor->m_transformedSize.x, pMonitor->m_transformedSize.y};
data.color = CHyprColor(1.0, 0.0, 1.0, 100.0 / 255.0); data.color = CHyprColor(1.0, 0.0, 1.0, 100.0 / 255.0);
m_sRenderPass.add(makeShared<CRectPassElement>(data)); m_renderPass.add(makeShared<CRectPassElement>(data));
damageBlinkCleanup = 1; damageBlinkCleanup = 1;
} else if (*PDAMAGEBLINK) { } else if (*PDAMAGEBLINK) {
damageBlinkCleanup++; damageBlinkCleanup++;
@ -1381,7 +1380,7 @@ void CHyprRenderer::renderMonitor(PHLMONITOR pMonitor) {
if (renderCursor) { if (renderCursor) {
TRACY_GPU_ZONE("RenderCursor"); TRACY_GPU_ZONE("RenderCursor");
g_pPointerManager->renderSoftwareCursorsFor(pMonitor->m_self.lock(), NOW, g_pHyprOpenGL->m_RenderData.damage); g_pPointerManager->renderSoftwareCursorsFor(pMonitor->m_self.lock(), NOW, g_pHyprOpenGL->m_renderData.damage);
} }
EMIT_HOOK_EVENT("render", RENDER_LAST_MOMENT); EMIT_HOOK_EVENT("render", RENDER_LAST_MOMENT);
@ -1390,7 +1389,7 @@ void CHyprRenderer::renderMonitor(PHLMONITOR pMonitor) {
TRACY_GPU_COLLECT; TRACY_GPU_COLLECT;
CRegion frameDamage{g_pHyprOpenGL->m_RenderData.damage}; CRegion frameDamage{g_pHyprOpenGL->m_renderData.damage};
const auto TRANSFORM = invertTransform(pMonitor->m_transform); const auto TRANSFORM = invertTransform(pMonitor->m_transform);
frameDamage.transform(wlTransformToHyprutils(TRANSFORM), pMonitor->m_transformedSize.x, pMonitor->m_transformedSize.y); frameDamage.transform(wlTransformToHyprutils(TRANSFORM), pMonitor->m_transformedSize.x, pMonitor->m_transformedSize.y);
@ -1964,29 +1963,29 @@ void CHyprRenderer::renderDragIcon(PHLMONITOR pMonitor, const Time::steady_tp& t
} }
void CHyprRenderer::setCursorSurface(SP<CWLSurface> surf, int hotspotX, int hotspotY, bool force) { void CHyprRenderer::setCursorSurface(SP<CWLSurface> surf, int hotspotX, int hotspotY, bool force) {
m_bCursorHasSurface = surf; m_cursorHasSurface = surf;
m_sLastCursorData.name = ""; m_lastCursorData.name = "";
m_sLastCursorData.surf = surf; m_lastCursorData.surf = surf;
m_sLastCursorData.hotspotX = hotspotX; m_lastCursorData.hotspotX = hotspotX;
m_sLastCursorData.hotspotY = hotspotY; m_lastCursorData.hotspotY = hotspotY;
if (m_bCursorHidden && !force) if (m_cursorHidden && !force)
return; return;
g_pCursorManager->setCursorSurface(surf, {hotspotX, hotspotY}); g_pCursorManager->setCursorSurface(surf, {hotspotX, hotspotY});
} }
void CHyprRenderer::setCursorFromName(const std::string& name, bool force) { void CHyprRenderer::setCursorFromName(const std::string& name, bool force) {
m_bCursorHasSurface = true; m_cursorHasSurface = true;
if (name == m_sLastCursorData.name && !force) if (name == m_lastCursorData.name && !force)
return; return;
m_sLastCursorData.name = name; m_lastCursorData.name = name;
m_sLastCursorData.surf.reset(); m_lastCursorData.surf.reset();
if (m_bCursorHidden && !force) if (m_cursorHidden && !force)
return; return;
g_pCursorManager->setCursorFromName(name); g_pCursorManager->setCursorFromName(name);
@ -1998,18 +1997,18 @@ void CHyprRenderer::ensureCursorRenderingMode() {
static auto PHIDEONKEY = CConfigValue<Hyprlang::INT>("cursor:hide_on_key_press"); static auto PHIDEONKEY = CConfigValue<Hyprlang::INT>("cursor:hide_on_key_press");
if (*PCURSORTIMEOUT <= 0) if (*PCURSORTIMEOUT <= 0)
m_sCursorHiddenConditions.hiddenOnTimeout = false; m_cursorHiddenConditions.hiddenOnTimeout = false;
if (*PHIDEONTOUCH == 0) if (*PHIDEONTOUCH == 0)
m_sCursorHiddenConditions.hiddenOnTouch = false; m_cursorHiddenConditions.hiddenOnTouch = false;
if (*PHIDEONKEY == 0) if (*PHIDEONKEY == 0)
m_sCursorHiddenConditions.hiddenOnKeyboard = false; m_cursorHiddenConditions.hiddenOnKeyboard = false;
if (*PCURSORTIMEOUT > 0) if (*PCURSORTIMEOUT > 0)
m_sCursorHiddenConditions.hiddenOnTimeout = *PCURSORTIMEOUT < g_pInputManager->m_lastCursorMovement.getSeconds(); m_cursorHiddenConditions.hiddenOnTimeout = *PCURSORTIMEOUT < g_pInputManager->m_lastCursorMovement.getSeconds();
const bool HIDE = m_sCursorHiddenConditions.hiddenOnTimeout || m_sCursorHiddenConditions.hiddenOnTouch || m_sCursorHiddenConditions.hiddenOnKeyboard; const bool HIDE = m_cursorHiddenConditions.hiddenOnTimeout || m_cursorHiddenConditions.hiddenOnTouch || m_cursorHiddenConditions.hiddenOnKeyboard;
if (HIDE == m_bCursorHidden) if (HIDE == m_cursorHidden)
return; return;
if (HIDE) { if (HIDE) {
@ -2040,26 +2039,26 @@ void CHyprRenderer::ensureCursorRenderingMode() {
void CHyprRenderer::setCursorHidden(bool hide) { void CHyprRenderer::setCursorHidden(bool hide) {
if (hide == m_bCursorHidden) if (hide == m_cursorHidden)
return; return;
m_bCursorHidden = hide; m_cursorHidden = hide;
if (hide) { if (hide) {
g_pPointerManager->resetCursorImage(); g_pPointerManager->resetCursorImage();
return; return;
} }
if (m_sLastCursorData.surf.has_value()) if (m_lastCursorData.surf.has_value())
setCursorSurface(m_sLastCursorData.surf.value(), m_sLastCursorData.hotspotX, m_sLastCursorData.hotspotY, true); setCursorSurface(m_lastCursorData.surf.value(), m_lastCursorData.hotspotX, m_lastCursorData.hotspotY, true);
else if (!m_sLastCursorData.name.empty()) else if (!m_lastCursorData.name.empty())
setCursorFromName(m_sLastCursorData.name, true); setCursorFromName(m_lastCursorData.name, true);
else else
setCursorFromName("left_ptr", true); setCursorFromName("left_ptr", true);
} }
bool CHyprRenderer::shouldRenderCursor() { bool CHyprRenderer::shouldRenderCursor() {
return !m_bCursorHidden && m_bCursorHasSurface; return !m_cursorHidden && m_cursorHasSurface;
} }
std::tuple<float, float, float> CHyprRenderer::getRenderTimes(PHLMONITOR pMonitor) { std::tuple<float, float, float> CHyprRenderer::getRenderTimes(PHLMONITOR pMonitor) {
@ -2082,15 +2081,15 @@ std::tuple<float, float, float> CHyprRenderer::getRenderTimes(PHLMONITOR pMonito
static int handleCrashLoop(void* data) { static int handleCrashLoop(void* data) {
g_pHyprNotificationOverlay->addNotification("Hyprland will crash in " + std::to_string(10 - (int)(g_pHyprRenderer->m_fCrashingDistort * 2.f)) + "s.", CHyprColor(0), 5000, g_pHyprNotificationOverlay->addNotification("Hyprland will crash in " + std::to_string(10 - (int)(g_pHyprRenderer->m_crashingDistort * 2.f)) + "s.", CHyprColor(0), 5000,
ICON_INFO); ICON_INFO);
g_pHyprRenderer->m_fCrashingDistort += 0.5f; g_pHyprRenderer->m_crashingDistort += 0.5f;
if (g_pHyprRenderer->m_fCrashingDistort >= 5.5f) if (g_pHyprRenderer->m_crashingDistort >= 5.5f)
raise(SIGABRT); raise(SIGABRT);
wl_event_source_timer_update(g_pHyprRenderer->m_pCrashingLoop, 1000); wl_event_source_timer_update(g_pHyprRenderer->m_crashingLoop, 1000);
return 1; return 1;
} }
@ -2098,13 +2097,13 @@ static int handleCrashLoop(void* data) {
void CHyprRenderer::initiateManualCrash() { void CHyprRenderer::initiateManualCrash() {
g_pHyprNotificationOverlay->addNotification("Manual crash initiated. Farewell...", CHyprColor(0), 5000, ICON_INFO); g_pHyprNotificationOverlay->addNotification("Manual crash initiated. Farewell...", CHyprColor(0), 5000, ICON_INFO);
m_pCrashingLoop = wl_event_loop_add_timer(g_pCompositor->m_wlEventLoop, handleCrashLoop, nullptr); m_crashingLoop = wl_event_loop_add_timer(g_pCompositor->m_wlEventLoop, handleCrashLoop, nullptr);
wl_event_source_timer_update(m_pCrashingLoop, 1000); wl_event_source_timer_update(m_crashingLoop, 1000);
m_bCrashingInProgress = true; m_crashingInProgress = true;
m_fCrashingDistort = 0.5; m_crashingDistort = 0.5;
g_pHyprOpenGL->m_tGlobalTimer.reset(); g_pHyprOpenGL->m_globalTimer.reset();
static auto PDT = (Hyprlang::INT* const*)(g_pConfigManager->getConfigValuePtr("debug:damage_tracking")); static auto PDT = (Hyprlang::INT* const*)(g_pConfigManager->getConfigValuePtr("debug:damage_tracking"));
@ -2169,9 +2168,9 @@ void CHyprRenderer::recheckSolitaryForMonitor(PHLMONITOR pMonitor) {
} }
SP<CRenderbuffer> CHyprRenderer::getOrCreateRenderbuffer(SP<Aquamarine::IBuffer> buffer, uint32_t fmt) { SP<CRenderbuffer> CHyprRenderer::getOrCreateRenderbuffer(SP<Aquamarine::IBuffer> buffer, uint32_t fmt) {
auto it = std::find_if(m_vRenderbuffers.begin(), m_vRenderbuffers.end(), [&](const auto& other) { return other->m_pHLBuffer == buffer; }); auto it = std::find_if(m_renderbuffers.begin(), m_renderbuffers.end(), [&](const auto& other) { return other->m_hlBuffer == buffer; });
if (it != m_vRenderbuffers.end()) if (it != m_renderbuffers.end())
return *it; return *it;
auto buf = makeShared<CRenderbuffer>(buffer, fmt); auto buf = makeShared<CRenderbuffer>(buffer, fmt);
@ -2179,7 +2178,7 @@ SP<CRenderbuffer> CHyprRenderer::getOrCreateRenderbuffer(SP<Aquamarine::IBuffer>
if (!buf->good()) if (!buf->good())
return nullptr; return nullptr;
m_vRenderbuffers.emplace_back(buf); m_renderbuffers.emplace_back(buf);
return buf; return buf;
} }
@ -2187,26 +2186,26 @@ void CHyprRenderer::makeEGLCurrent() {
if (!g_pCompositor || !g_pHyprOpenGL) if (!g_pCompositor || !g_pHyprOpenGL)
return; return;
if (eglGetCurrentContext() != g_pHyprOpenGL->m_pEglContext) if (eglGetCurrentContext() != g_pHyprOpenGL->m_eglContext)
eglMakeCurrent(g_pHyprOpenGL->m_pEglDisplay, EGL_NO_SURFACE, EGL_NO_SURFACE, g_pHyprOpenGL->m_pEglContext); eglMakeCurrent(g_pHyprOpenGL->m_eglDisplay, EGL_NO_SURFACE, EGL_NO_SURFACE, g_pHyprOpenGL->m_eglContext);
} }
void CHyprRenderer::unsetEGL() { void CHyprRenderer::unsetEGL() {
if (!g_pHyprOpenGL) if (!g_pHyprOpenGL)
return; return;
eglMakeCurrent(g_pHyprOpenGL->m_pEglDisplay, EGL_NO_SURFACE, EGL_NO_SURFACE, EGL_NO_CONTEXT); 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, CFramebuffer* fb, bool simple) { bool CHyprRenderer::beginRender(PHLMONITOR pMonitor, CRegion& damage, eRenderMode mode, SP<IHLBuffer> buffer, CFramebuffer* fb, bool simple) {
makeEGLCurrent(); makeEGLCurrent();
m_sRenderPass.clear(); m_renderPass.clear();
m_eRenderMode = mode; m_renderMode = mode;
g_pHyprOpenGL->m_RenderData.pMonitor = pMonitor; // has to be set cuz allocs g_pHyprOpenGL->m_renderData.pMonitor = pMonitor; // has to be set cuz allocs
if (mode == RENDER_MODE_FULL_FAKE) { if (mode == RENDER_MODE_FULL_FAKE) {
RASSERT(fb, "Cannot render FULL_FAKE without a provided fb!"); RASSERT(fb, "Cannot render FULL_FAKE without a provided fb!");
@ -2223,22 +2222,22 @@ bool CHyprRenderer::beginRender(PHLMONITOR pMonitor, CRegion& damage, eRenderMod
static constexpr const int HL_BUFFER_AGE = 2; static constexpr const int HL_BUFFER_AGE = 2;
if (!buffer) { if (!buffer) {
m_pCurrentBuffer = pMonitor->m_output->swapchain->next(nullptr); m_currentBuffer = pMonitor->m_output->swapchain->next(nullptr);
if (!m_pCurrentBuffer) { if (!m_currentBuffer) {
Debug::log(ERR, "Failed to acquire swapchain buffer for {}", pMonitor->m_name); Debug::log(ERR, "Failed to acquire swapchain buffer for {}", pMonitor->m_name);
return false; return false;
} }
} else } else
m_pCurrentBuffer = buffer; m_currentBuffer = buffer;
try { try {
m_pCurrentRenderbuffer = getOrCreateRenderbuffer(m_pCurrentBuffer, pMonitor->m_output->state->state().drmFormat); m_currentRenderbuffer = getOrCreateRenderbuffer(m_currentBuffer, pMonitor->m_output->state->state().drmFormat);
} catch (std::exception& e) { } catch (std::exception& e) {
Debug::log(ERR, "getOrCreateRenderbuffer failed for {}", pMonitor->m_name); Debug::log(ERR, "getOrCreateRenderbuffer failed for {}", pMonitor->m_name);
return false; return false;
} }
if (!m_pCurrentRenderbuffer) { if (!m_currentRenderbuffer) {
Debug::log(ERR, "failed to start a render pass for output {}, no RBO could be obtained", pMonitor->m_name); Debug::log(ERR, "failed to start a render pass for output {}, no RBO could be obtained", pMonitor->m_name);
return false; return false;
} }
@ -2248,9 +2247,9 @@ bool CHyprRenderer::beginRender(PHLMONITOR pMonitor, CRegion& damage, eRenderMod
pMonitor->m_damage.rotate(); pMonitor->m_damage.rotate();
} }
m_pCurrentRenderbuffer->bind(); m_currentRenderbuffer->bind();
if (simple) if (simple)
g_pHyprOpenGL->beginSimple(pMonitor, damage, m_pCurrentRenderbuffer); g_pHyprOpenGL->beginSimple(pMonitor, damage, m_currentRenderbuffer);
else else
g_pHyprOpenGL->begin(pMonitor, damage); g_pHyprOpenGL->begin(pMonitor, damage);
@ -2258,55 +2257,55 @@ bool CHyprRenderer::beginRender(PHLMONITOR pMonitor, CRegion& damage, eRenderMod
} }
void CHyprRenderer::endRender(const std::function<void()>& renderingDoneCallback) { void CHyprRenderer::endRender(const std::function<void()>& renderingDoneCallback) {
const auto PMONITOR = g_pHyprOpenGL->m_RenderData.pMonitor; const auto PMONITOR = g_pHyprOpenGL->m_renderData.pMonitor;
static auto PNVIDIAANTIFLICKER = CConfigValue<Hyprlang::INT>("opengl:nvidia_anti_flicker"); static auto PNVIDIAANTIFLICKER = CConfigValue<Hyprlang::INT>("opengl:nvidia_anti_flicker");
g_pHyprOpenGL->m_RenderData.damage = m_sRenderPass.render(g_pHyprOpenGL->m_RenderData.damage); g_pHyprOpenGL->m_renderData.damage = m_renderPass.render(g_pHyprOpenGL->m_renderData.damage);
auto cleanup = CScopeGuard([this]() { auto cleanup = CScopeGuard([this]() {
if (m_pCurrentRenderbuffer) if (m_currentRenderbuffer)
m_pCurrentRenderbuffer->unbind(); m_currentRenderbuffer->unbind();
m_pCurrentRenderbuffer = nullptr; m_currentRenderbuffer = nullptr;
m_pCurrentBuffer = nullptr; m_currentBuffer = nullptr;
}); });
if (m_eRenderMode != RENDER_MODE_TO_BUFFER_READ_ONLY) if (m_renderMode != RENDER_MODE_TO_BUFFER_READ_ONLY)
g_pHyprOpenGL->end(); g_pHyprOpenGL->end();
else { else {
g_pHyprOpenGL->m_RenderData.pMonitor.reset(); g_pHyprOpenGL->m_renderData.pMonitor.reset();
g_pHyprOpenGL->m_RenderData.mouseZoomFactor = 1.f; g_pHyprOpenGL->m_renderData.mouseZoomFactor = 1.f;
g_pHyprOpenGL->m_RenderData.mouseZoomUseMouse = true; g_pHyprOpenGL->m_renderData.mouseZoomUseMouse = true;
} }
// send all queued opengl commands so rendering starts happening immediately // send all queued opengl commands so rendering starts happening immediately
glFlush(); glFlush();
if (m_eRenderMode == RENDER_MODE_FULL_FAKE) if (m_renderMode == RENDER_MODE_FULL_FAKE)
return; return;
if (m_eRenderMode == RENDER_MODE_NORMAL) if (m_renderMode == RENDER_MODE_NORMAL)
PMONITOR->m_output->state->setBuffer(m_pCurrentBuffer); PMONITOR->m_output->state->setBuffer(m_currentBuffer);
UP<CEGLSync> eglSync = CEGLSync::create(); UP<CEGLSync> eglSync = CEGLSync::create();
if (eglSync && eglSync->isValid()) { if (eglSync && eglSync->isValid()) {
for (auto const& buf : usedAsyncBuffers) { for (auto const& buf : m_usedAsyncBuffers) {
for (const auto& releaser : buf->m_syncReleasers) { for (const auto& releaser : buf->m_syncReleasers) {
releaser->addSyncFileFd(eglSync->fd()); releaser->addSyncFileFd(eglSync->fd());
} }
} }
// release buffer refs with release points now, since syncReleaser handles actual buffer release based on EGLSync // release buffer refs with release points now, since syncReleaser handles actual buffer release based on EGLSync
std::erase_if(usedAsyncBuffers, [](const auto& buf) { return !buf->m_syncReleasers.empty(); }); std::erase_if(m_usedAsyncBuffers, [](const auto& buf) { return !buf->m_syncReleasers.empty(); });
// release buffer refs without release points when EGLSync sync_file/fence is signalled // release buffer refs without release points when EGLSync sync_file/fence is signalled
g_pEventLoopManager->doOnReadable(eglSync->fd().duplicate(), [renderingDoneCallback, prevbfs = std::move(usedAsyncBuffers)]() mutable { g_pEventLoopManager->doOnReadable(eglSync->fd().duplicate(), [renderingDoneCallback, prevbfs = std::move(m_usedAsyncBuffers)]() mutable {
prevbfs.clear(); prevbfs.clear();
if (renderingDoneCallback) if (renderingDoneCallback)
renderingDoneCallback(); renderingDoneCallback();
}); });
usedAsyncBuffers.clear(); m_usedAsyncBuffers.clear();
if (m_eRenderMode == RENDER_MODE_NORMAL) { if (m_renderMode == RENDER_MODE_NORMAL) {
PMONITOR->m_inFence = eglSync->takeFd(); PMONITOR->m_inFence = eglSync->takeFd();
PMONITOR->m_output->state->setExplicitInFence(PMONITOR->m_inFence.get()); PMONITOR->m_output->state->setExplicitInFence(PMONITOR->m_inFence.get());
} }
@ -2317,22 +2316,22 @@ void CHyprRenderer::endRender(const std::function<void()>& renderingDoneCallback
if (isNvidia() && *PNVIDIAANTIFLICKER) if (isNvidia() && *PNVIDIAANTIFLICKER)
glFinish(); glFinish();
usedAsyncBuffers.clear(); // release all buffer refs and hope implicit sync works m_usedAsyncBuffers.clear(); // release all buffer refs and hope implicit sync works
if (renderingDoneCallback) if (renderingDoneCallback)
renderingDoneCallback(); renderingDoneCallback();
} }
} }
void CHyprRenderer::onRenderbufferDestroy(CRenderbuffer* rb) { void CHyprRenderer::onRenderbufferDestroy(CRenderbuffer* rb) {
std::erase_if(m_vRenderbuffers, [&](const auto& rbo) { return rbo.get() == rb; }); std::erase_if(m_renderbuffers, [&](const auto& rbo) { return rbo.get() == rb; });
} }
SP<CRenderbuffer> CHyprRenderer::getCurrentRBO() { SP<CRenderbuffer> CHyprRenderer::getCurrentRBO() {
return m_pCurrentRenderbuffer; return m_currentRenderbuffer;
} }
bool CHyprRenderer::isNvidia() { bool CHyprRenderer::isNvidia() {
return m_bNvidia; return m_nvidia;
} }
SExplicitSyncSettings CHyprRenderer::getExplicitSyncSettings(SP<Aquamarine::IOutput> output) { SExplicitSyncSettings CHyprRenderer::getExplicitSyncSettings(SP<Aquamarine::IOutput> output) {
@ -2353,7 +2352,7 @@ SExplicitSyncSettings CHyprRenderer::getExplicitSyncSettings(SP<Aquamarine::IOut
if (*PENABLEEXPLICIT == 2 /* auto */) if (*PENABLEEXPLICIT == 2 /* auto */)
settings.explicitEnabled = true; settings.explicitEnabled = true;
if (*PENABLEEXPLICITKMS == 2 /* auto */) { if (*PENABLEEXPLICITKMS == 2 /* auto */) {
if (!m_bNvidia) if (!m_nvidia)
settings.explicitKMSEnabled = true; settings.explicitKMSEnabled = true;
else { else {
settings.explicitKMSEnabled = isNvidiaDriverVersionAtLeast(560); settings.explicitKMSEnabled = isNvidiaDriverVersionAtLeast(560);
@ -2365,13 +2364,13 @@ SExplicitSyncSettings CHyprRenderer::getExplicitSyncSettings(SP<Aquamarine::IOut
void CHyprRenderer::addWindowToRenderUnfocused(PHLWINDOW window) { void CHyprRenderer::addWindowToRenderUnfocused(PHLWINDOW window) {
static auto PFPS = CConfigValue<Hyprlang::INT>("misc:render_unfocused_fps"); static auto PFPS = CConfigValue<Hyprlang::INT>("misc:render_unfocused_fps");
if (std::find(m_vRenderUnfocused.begin(), m_vRenderUnfocused.end(), window) != m_vRenderUnfocused.end()) if (std::find(m_renderUnfocused.begin(), m_renderUnfocused.end(), window) != m_renderUnfocused.end())
return; return;
m_vRenderUnfocused.emplace_back(window); m_renderUnfocused.emplace_back(window);
if (!m_tRenderUnfocusedTimer->armed()) if (!m_renderUnfocusedTimer->armed())
m_tRenderUnfocusedTimer->updateTimeout(std::chrono::milliseconds(1000 / *PFPS)); m_renderUnfocusedTimer->updateTimeout(std::chrono::milliseconds(1000 / *PFPS));
} }
void CHyprRenderer::makeRawWindowSnapshot(PHLWINDOW pWindow, CFramebuffer* pFramebuffer) { void CHyprRenderer::makeRawWindowSnapshot(PHLWINDOW pWindow, CFramebuffer* pFramebuffer) {
@ -2389,7 +2388,7 @@ void CHyprRenderer::makeRawWindowSnapshot(PHLWINDOW pWindow, CFramebuffer* pFram
makeEGLCurrent(); makeEGLCurrent();
pFramebuffer->alloc(PMONITOR->m_pixelSize.x, PMONITOR->m_pixelSize.y, PMONITOR->m_output->state->state().drmFormat); pFramebuffer->alloc(PMONITOR->m_pixelSize.x, PMONITOR->m_pixelSize.y, PMONITOR->m_output->state->state().drmFormat);
pFramebuffer->addStencil(g_pHyprOpenGL->m_RenderData.pCurrentMonData->stencilTex); pFramebuffer->addStencil(g_pHyprOpenGL->m_renderData.pCurrentMonData->stencilTex);
beginRender(PMONITOR, fakeDamage, RENDER_MODE_FULL_FAKE, nullptr, pFramebuffer); beginRender(PMONITOR, fakeDamage, RENDER_MODE_FULL_FAKE, nullptr, pFramebuffer);
@ -2407,7 +2406,7 @@ void CHyprRenderer::makeRawWindowSnapshot(PHLWINDOW pWindow, CFramebuffer* pFram
// TODO: how can we make this the size of the window? setting it to window's size makes the entire screen render with the wrong res forever more. odd. // TODO: how can we make this the size of the window? setting it to window's size makes the entire screen render with the wrong res forever more. odd.
glViewport(0, 0, PMONITOR->m_pixelSize.x, PMONITOR->m_pixelSize.y); glViewport(0, 0, PMONITOR->m_pixelSize.x, PMONITOR->m_pixelSize.y);
g_pHyprOpenGL->m_RenderData.currentFB = pFramebuffer; g_pHyprOpenGL->m_renderData.currentFB = pFramebuffer;
g_pHyprOpenGL->clear(CHyprColor(0, 0, 0, 0)); // JIC g_pHyprOpenGL->clear(CHyprColor(0, 0, 0, 0)); // JIC
@ -2437,7 +2436,7 @@ void CHyprRenderer::makeWindowSnapshot(PHLWINDOW pWindow) {
makeEGLCurrent(); makeEGLCurrent();
const auto PFRAMEBUFFER = &g_pHyprOpenGL->m_mWindowFramebuffers[ref]; const auto PFRAMEBUFFER = &g_pHyprOpenGL->m_windowFramebuffers[ref];
PFRAMEBUFFER->alloc(PMONITOR->m_pixelSize.x, PMONITOR->m_pixelSize.y, PMONITOR->m_output->state->state().drmFormat); PFRAMEBUFFER->alloc(PMONITOR->m_pixelSize.x, PMONITOR->m_pixelSize.y, PMONITOR->m_output->state->state().drmFormat);
@ -2481,7 +2480,7 @@ void CHyprRenderer::makeLayerSnapshot(PHLLS pLayer) {
makeEGLCurrent(); makeEGLCurrent();
const auto PFRAMEBUFFER = &g_pHyprOpenGL->m_mLayerFramebuffers[pLayer]; const auto PFRAMEBUFFER = &g_pHyprOpenGL->m_layerFramebuffers[pLayer];
PFRAMEBUFFER->alloc(PMONITOR->m_pixelSize.x, PMONITOR->m_pixelSize.y, PMONITOR->m_output->state->state().drmFormat); PFRAMEBUFFER->alloc(PMONITOR->m_pixelSize.x, PMONITOR->m_pixelSize.y, PMONITOR->m_output->state->state().drmFormat);
@ -2509,10 +2508,10 @@ void CHyprRenderer::renderSnapshot(PHLWINDOW pWindow) {
PHLWINDOWREF ref{pWindow}; PHLWINDOWREF ref{pWindow};
if (!g_pHyprOpenGL->m_mWindowFramebuffers.contains(ref)) if (!g_pHyprOpenGL->m_windowFramebuffers.contains(ref))
return; return;
const auto FBDATA = &g_pHyprOpenGL->m_mWindowFramebuffers.at(ref); const auto FBDATA = &g_pHyprOpenGL->m_windowFramebuffers.at(ref);
if (!FBDATA->getTexture()) if (!FBDATA->getTexture())
return; return;
@ -2536,10 +2535,10 @@ void CHyprRenderer::renderSnapshot(PHLWINDOW pWindow) {
CRectPassElement::SRectData data; CRectPassElement::SRectData data;
data.box = {0, 0, g_pHyprOpenGL->m_RenderData.pMonitor->m_pixelSize.x, g_pHyprOpenGL->m_RenderData.pMonitor->m_pixelSize.y}; data.box = {0, 0, g_pHyprOpenGL->m_renderData.pMonitor->m_pixelSize.x, g_pHyprOpenGL->m_renderData.pMonitor->m_pixelSize.y};
data.color = CHyprColor(0, 0, 0, *PDIMAROUND * pWindow->m_alpha->value()); data.color = CHyprColor(0, 0, 0, *PDIMAROUND * pWindow->m_alpha->value());
m_sRenderPass.add(makeShared<CRectPassElement>(data)); m_renderPass.add(makeShared<CRectPassElement>(data));
damageMonitor(PMONITOR); damageMonitor(PMONITOR);
} }
@ -2550,14 +2549,14 @@ void CHyprRenderer::renderSnapshot(PHLWINDOW pWindow) {
data.a = pWindow->m_alpha->value(); data.a = pWindow->m_alpha->value();
data.damage = fakeDamage; data.damage = fakeDamage;
m_sRenderPass.add(makeShared<CTexPassElement>(data)); m_renderPass.add(makeShared<CTexPassElement>(data));
} }
void CHyprRenderer::renderSnapshot(PHLLS pLayer) { void CHyprRenderer::renderSnapshot(PHLLS pLayer) {
if (!g_pHyprOpenGL->m_mLayerFramebuffers.contains(pLayer)) if (!g_pHyprOpenGL->m_layerFramebuffers.contains(pLayer))
return; return;
const auto FBDATA = &g_pHyprOpenGL->m_mLayerFramebuffers.at(pLayer); const auto FBDATA = &g_pHyprOpenGL->m_layerFramebuffers.at(pLayer);
if (!FBDATA->getTexture()) if (!FBDATA->getTexture())
return; return;
@ -2586,5 +2585,5 @@ void CHyprRenderer::renderSnapshot(PHLLS pLayer) {
data.a = pLayer->m_alpha->value(); data.a = pLayer->m_alpha->value();
data.damage = fakeDamage; data.damage = fakeDamage;
m_sRenderPass.add(makeShared<CTexPassElement>(data)); m_renderPass.add(makeShared<CTexPassElement>(data));
} }

40
src/render/Renderer.hpp
View File

@ -91,29 +91,29 @@ class CHyprRenderer {
bool m_bBlockSurfaceFeedback = false; bool m_bBlockSurfaceFeedback = false;
bool m_bRenderingSnapshot = false; bool m_bRenderingSnapshot = false;
PHLMONITORREF m_pMostHzMonitor; PHLMONITORREF m_mostHzMonitor;
bool m_bDirectScanoutBlocked = false; bool m_directScanoutBlocked = false;
void setSurfaceScanoutMode(SP<CWLSurfaceResource> surface, PHLMONITOR monitor); // nullptr monitor resets void setSurfaceScanoutMode(SP<CWLSurfaceResource> surface, PHLMONITOR monitor); // nullptr monitor resets
void initiateManualCrash(); void initiateManualCrash();
bool m_bCrashingInProgress = false; bool m_crashingInProgress = false;
float m_fCrashingDistort = 0.5f; float m_crashingDistort = 0.5f;
wl_event_source* m_pCrashingLoop = nullptr; wl_event_source* m_crashingLoop = nullptr;
wl_event_source* m_pCursorTicker = nullptr; wl_event_source* m_cursorTicker = nullptr;
CTimer m_tRenderTimer; CTimer m_renderTimer;
std::vector<CHLBufferReference> usedAsyncBuffers; std::vector<CHLBufferReference> m_usedAsyncBuffers;
struct { struct {
int hotspotX = 0; int hotspotX = 0;
int hotspotY = 0; int hotspotY = 0;
std::optional<SP<CWLSurface>> surf; std::optional<SP<CWLSurface>> surf;
std::string name; std::string name;
} m_sLastCursorData; } m_lastCursorData;
CRenderPass m_sRenderPass = {}; CRenderPass m_renderPass = {};
private: private:
void arrangeLayerArray(PHLMONITOR, const std::vector<PHLLSREF>&, bool, CBox*); void arrangeLayerArray(PHLMONITOR, const std::vector<PHLLSREF>&, bool, CBox*);
@ -131,23 +131,23 @@ class CHyprRenderer {
bool commitPendingAndDoExplicitSync(PHLMONITOR pMonitor); bool commitPendingAndDoExplicitSync(PHLMONITOR pMonitor);
bool m_bCursorHidden = false; bool m_cursorHidden = false;
bool m_bCursorHasSurface = false; bool m_cursorHasSurface = false;
SP<CRenderbuffer> m_pCurrentRenderbuffer = nullptr; SP<CRenderbuffer> m_currentRenderbuffer = nullptr;
SP<Aquamarine::IBuffer> m_pCurrentBuffer = nullptr; SP<Aquamarine::IBuffer> m_currentBuffer = nullptr;
eRenderMode m_eRenderMode = RENDER_MODE_NORMAL; eRenderMode m_renderMode = RENDER_MODE_NORMAL;
bool m_bNvidia = false; bool m_nvidia = false;
struct { struct {
bool hiddenOnTouch = false; bool hiddenOnTouch = false;
bool hiddenOnTimeout = false; bool hiddenOnTimeout = false;
bool hiddenOnKeyboard = false; bool hiddenOnKeyboard = false;
} m_sCursorHiddenConditions; } m_cursorHiddenConditions;
SP<CRenderbuffer> getOrCreateRenderbuffer(SP<Aquamarine::IBuffer> buffer, uint32_t fmt); SP<CRenderbuffer> getOrCreateRenderbuffer(SP<Aquamarine::IBuffer> buffer, uint32_t fmt);
std::vector<SP<CRenderbuffer>> m_vRenderbuffers; std::vector<SP<CRenderbuffer>> m_renderbuffers;
std::vector<PHLWINDOWREF> m_vRenderUnfocused; std::vector<PHLWINDOWREF> m_renderUnfocused;
SP<CEventLoopTimer> m_tRenderUnfocusedTimer; SP<CEventLoopTimer> m_renderUnfocusedTimer;
friend class CHyprOpenGLImpl; friend class CHyprOpenGLImpl;
friend class CToplevelExportFrame; friend class CToplevelExportFrame;

3
src/render/Shader.hpp
View File

@ -78,7 +78,4 @@ class CShader {
GLint noise = -1; GLint noise = -1;
void destroy(); void destroy();
private:
std::unordered_map<std::string, GLint> m_muUniforms;
}; };

66
src/render/Texture.cpp
View File

@ -15,7 +15,7 @@ CTexture::~CTexture() {
destroyTexture(); destroyTexture();
} }
CTexture::CTexture(uint32_t drmFormat, uint8_t* pixels, uint32_t stride, const Vector2D& size_, bool keepDataCopy) : m_iDrmFormat(drmFormat), m_bKeepDataCopy(keepDataCopy) { CTexture::CTexture(uint32_t drmFormat, uint8_t* pixels, uint32_t stride, const Vector2D& size_, bool keepDataCopy) : m_drmFormat(drmFormat), m_keepDataCopy(keepDataCopy) {
createFromShm(drmFormat, pixels, stride, size_); createFromShm(drmFormat, pixels, stride, size_);
} }
@ -23,11 +23,11 @@ CTexture::CTexture(const Aquamarine::SDMABUFAttrs& attrs, void* image) {
createFromDma(attrs, image); createFromDma(attrs, image);
} }
CTexture::CTexture(const SP<Aquamarine::IBuffer> buffer, bool keepDataCopy) : m_bKeepDataCopy(keepDataCopy) { CTexture::CTexture(const SP<Aquamarine::IBuffer> buffer, bool keepDataCopy) : m_keepDataCopy(keepDataCopy) {
if (!buffer) if (!buffer)
return; return;
m_bOpaque = buffer->opaque; m_opaque = buffer->opaque;
auto attrs = buffer->dmabuf(); auto attrs = buffer->dmabuf();
@ -42,7 +42,7 @@ CTexture::CTexture(const SP<Aquamarine::IBuffer> buffer, bool keepDataCopy) : m_
auto [pixelData, fmt, bufLen] = buffer->beginDataPtr(0); auto [pixelData, fmt, bufLen] = buffer->beginDataPtr(0);
m_iDrmFormat = fmt; m_drmFormat = fmt;
createFromShm(fmt, pixelData, bufLen, shm.size); createFromShm(fmt, pixelData, bufLen, shm.size);
return; return;
@ -64,12 +64,12 @@ void CTexture::createFromShm(uint32_t drmFormat, uint8_t* pixels, uint32_t strid
const auto format = NFormatUtils::getPixelFormatFromDRM(drmFormat); const auto format = NFormatUtils::getPixelFormatFromDRM(drmFormat);
ASSERT(format); ASSERT(format);
m_iType = format->withAlpha ? TEXTURE_RGBA : TEXTURE_RGBX; m_type = format->withAlpha ? TEXTURE_RGBA : TEXTURE_RGBX;
m_vSize = size_; m_size = size_;
m_isSynchronous = true; m_isSynchronous = true;
allocate(); allocate();
GLCALL(glBindTexture(GL_TEXTURE_2D, m_iTexID)); GLCALL(glBindTexture(GL_TEXTURE_2D, m_texID));
GLCALL(glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE)); GLCALL(glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE));
GLCALL(glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE)); GLCALL(glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE));
#ifndef GLES2 #ifndef GLES2
@ -83,30 +83,30 @@ void CTexture::createFromShm(uint32_t drmFormat, uint8_t* pixels, uint32_t strid
GLCALL(glPixelStorei(GL_UNPACK_ROW_LENGTH_EXT, 0)); GLCALL(glPixelStorei(GL_UNPACK_ROW_LENGTH_EXT, 0));
GLCALL(glBindTexture(GL_TEXTURE_2D, 0)); GLCALL(glBindTexture(GL_TEXTURE_2D, 0));
if (m_bKeepDataCopy) { if (m_keepDataCopy) {
m_vDataCopy.resize(stride * size_.y); m_dataCopy.resize(stride * size_.y);
memcpy(m_vDataCopy.data(), pixels, stride * size_.y); memcpy(m_dataCopy.data(), pixels, stride * size_.y);
} }
} }
void CTexture::createFromDma(const Aquamarine::SDMABUFAttrs& attrs, void* image) { void CTexture::createFromDma(const Aquamarine::SDMABUFAttrs& attrs, void* image) {
if (!g_pHyprOpenGL->m_sProc.glEGLImageTargetTexture2DOES) { if (!g_pHyprOpenGL->m_proc.glEGLImageTargetTexture2DOES) {
Debug::log(ERR, "Cannot create a dmabuf texture: no glEGLImageTargetTexture2DOES"); Debug::log(ERR, "Cannot create a dmabuf texture: no glEGLImageTargetTexture2DOES");
return; return;
} }
m_bOpaque = NFormatUtils::isFormatOpaque(attrs.format); m_opaque = NFormatUtils::isFormatOpaque(attrs.format);
m_iTarget = GL_TEXTURE_2D; m_target = GL_TEXTURE_2D;
m_iType = TEXTURE_RGBA; m_type = TEXTURE_RGBA;
m_vSize = attrs.size; m_size = attrs.size;
m_iType = NFormatUtils::isFormatOpaque(attrs.format) ? TEXTURE_RGBX : TEXTURE_RGBA; m_type = NFormatUtils::isFormatOpaque(attrs.format) ? TEXTURE_RGBX : TEXTURE_RGBA;
allocate(); allocate();
m_pEglImage = image; m_eglImage = image;
GLCALL(glBindTexture(GL_TEXTURE_2D, m_iTexID)); GLCALL(glBindTexture(GL_TEXTURE_2D, m_texID));
GLCALL(glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE)); GLCALL(glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE));
GLCALL(glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE)); GLCALL(glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE));
GLCALL(g_pHyprOpenGL->m_sProc.glEGLImageTargetTexture2DOES(m_iTarget, image)); GLCALL(g_pHyprOpenGL->m_proc.glEGLImageTargetTexture2DOES(m_target, image));
GLCALL(glBindTexture(GL_TEXTURE_2D, 0)); GLCALL(glBindTexture(GL_TEXTURE_2D, 0));
} }
@ -116,9 +116,9 @@ void CTexture::update(uint32_t drmFormat, uint8_t* pixels, uint32_t stride, cons
const auto format = NFormatUtils::getPixelFormatFromDRM(drmFormat); const auto format = NFormatUtils::getPixelFormatFromDRM(drmFormat);
ASSERT(format); ASSERT(format);
glBindTexture(GL_TEXTURE_2D, m_iTexID); glBindTexture(GL_TEXTURE_2D, m_texID);
auto rects = damage.copy().intersect(CBox{{}, m_vSize}).getRects(); auto rects = damage.copy().intersect(CBox{{}, m_size}).getRects();
#ifndef GLES2 #ifndef GLES2
if (format->flipRB) { if (format->flipRB) {
@ -143,28 +143,28 @@ void CTexture::update(uint32_t drmFormat, uint8_t* pixels, uint32_t stride, cons
glBindTexture(GL_TEXTURE_2D, 0); glBindTexture(GL_TEXTURE_2D, 0);
if (m_bKeepDataCopy) { if (m_keepDataCopy) {
m_vDataCopy.resize(stride * m_vSize.y); m_dataCopy.resize(stride * m_size.y);
memcpy(m_vDataCopy.data(), pixels, stride * m_vSize.y); memcpy(m_dataCopy.data(), pixels, stride * m_size.y);
} }
} }
void CTexture::destroyTexture() { void CTexture::destroyTexture() {
if (m_iTexID) { if (m_texID) {
GLCALL(glDeleteTextures(1, &m_iTexID)); GLCALL(glDeleteTextures(1, &m_texID));
m_iTexID = 0; m_texID = 0;
} }
if (m_pEglImage) if (m_eglImage)
g_pHyprOpenGL->m_sProc.eglDestroyImageKHR(g_pHyprOpenGL->m_pEglDisplay, m_pEglImage); g_pHyprOpenGL->m_proc.eglDestroyImageKHR(g_pHyprOpenGL->m_eglDisplay, m_eglImage);
m_pEglImage = nullptr; m_eglImage = nullptr;
} }
void CTexture::allocate() { void CTexture::allocate() {
if (!m_iTexID) if (!m_texID)
GLCALL(glGenTextures(1, &m_iTexID)); GLCALL(glGenTextures(1, &m_texID));
} }
const std::vector<uint8_t>& CTexture::dataCopy() { const std::vector<uint8_t>& CTexture::dataCopy() {
return m_vDataCopy; return m_dataCopy;
} }

20
src/render/Texture.hpp
View File

@ -35,21 +35,21 @@ class CTexture {
void update(uint32_t drmFormat, uint8_t* pixels, uint32_t stride, const CRegion& damage); void update(uint32_t drmFormat, uint8_t* pixels, uint32_t stride, const CRegion& damage);
const std::vector<uint8_t>& dataCopy(); const std::vector<uint8_t>& dataCopy();
eTextureType m_iType = TEXTURE_RGBA; eTextureType m_type = TEXTURE_RGBA;
GLenum m_iTarget = GL_TEXTURE_2D; GLenum m_target = GL_TEXTURE_2D;
GLuint m_iTexID = 0; GLuint m_texID = 0;
Vector2D m_vSize = {}; Vector2D m_size = {};
void* m_pEglImage = nullptr; void* m_eglImage = nullptr;
eTransform m_eTransform = HYPRUTILS_TRANSFORM_NORMAL; eTransform m_transform = HYPRUTILS_TRANSFORM_NORMAL;
bool m_bOpaque = false; bool m_opaque = false;
uint32_t m_iDrmFormat = 0; // for shm uint32_t m_drmFormat = 0; // for shm
bool m_isSynchronous = false; bool m_isSynchronous = false;
private: private:
void createFromShm(uint32_t drmFormat, uint8_t* pixels, uint32_t stride, const Vector2D& size); void createFromShm(uint32_t drmFormat, uint8_t* pixels, uint32_t stride, const Vector2D& size);
void createFromDma(const Aquamarine::SDMABUFAttrs&, void* image); void createFromDma(const Aquamarine::SDMABUFAttrs&, void* image);
bool m_bKeepDataCopy = false; bool m_keepDataCopy = false;
std::vector<uint8_t> m_vDataCopy; std::vector<uint8_t> m_dataCopy;
}; };

74
src/render/decorations/CHyprBorderDecoration.cpp
View File

@ -6,42 +6,42 @@
#include "../Renderer.hpp" #include "../Renderer.hpp"
#include "../../managers/HookSystemManager.hpp" #include "../../managers/HookSystemManager.hpp"
CHyprBorderDecoration::CHyprBorderDecoration(PHLWINDOW pWindow) : IHyprWindowDecoration(pWindow), m_pWindow(pWindow) { CHyprBorderDecoration::CHyprBorderDecoration(PHLWINDOW pWindow) : IHyprWindowDecoration(pWindow), m_window(pWindow) {
; ;
} }
SDecorationPositioningInfo CHyprBorderDecoration::getPositioningInfo() { SDecorationPositioningInfo CHyprBorderDecoration::getPositioningInfo() {
const auto BORDERSIZE = m_pWindow->getRealBorderSize(); const auto BORDERSIZE = m_window->getRealBorderSize();
m_seExtents = {{BORDERSIZE, BORDERSIZE}, {BORDERSIZE, BORDERSIZE}}; m_extents = {{BORDERSIZE, BORDERSIZE}, {BORDERSIZE, BORDERSIZE}};
if (doesntWantBorders()) if (doesntWantBorders())
m_seExtents = {{}, {}}; m_extents = {{}, {}};
SDecorationPositioningInfo info; SDecorationPositioningInfo info;
info.priority = 10000; info.priority = 10000;
info.policy = DECORATION_POSITION_STICKY; info.policy = DECORATION_POSITION_STICKY;
info.desiredExtents = m_seExtents; info.desiredExtents = m_extents;
info.reserved = true; info.reserved = true;
info.edges = DECORATION_EDGE_BOTTOM | DECORATION_EDGE_LEFT | DECORATION_EDGE_RIGHT | DECORATION_EDGE_TOP; info.edges = DECORATION_EDGE_BOTTOM | DECORATION_EDGE_LEFT | DECORATION_EDGE_RIGHT | DECORATION_EDGE_TOP;
m_seReportedExtents = m_seExtents; m_reportedExtents = m_extents;
return info; return info;
} }
void CHyprBorderDecoration::onPositioningReply(const SDecorationPositioningReply& reply) { void CHyprBorderDecoration::onPositioningReply(const SDecorationPositioningReply& reply) {
m_bAssignedGeometry = reply.assignedGeometry; m_assignedGeometry = reply.assignedGeometry;
} }
CBox CHyprBorderDecoration::assignedBoxGlobal() { CBox CHyprBorderDecoration::assignedBoxGlobal() {
CBox box = m_bAssignedGeometry; CBox box = m_assignedGeometry;
box.translate(g_pDecorationPositioner->getEdgeDefinedPoint(DECORATION_EDGE_BOTTOM | DECORATION_EDGE_LEFT | DECORATION_EDGE_RIGHT | DECORATION_EDGE_TOP, m_pWindow.lock())); box.translate(g_pDecorationPositioner->getEdgeDefinedPoint(DECORATION_EDGE_BOTTOM | DECORATION_EDGE_LEFT | DECORATION_EDGE_RIGHT | DECORATION_EDGE_TOP, m_window.lock()));
const auto PWORKSPACE = m_pWindow->m_workspace; const auto PWORKSPACE = m_window->m_workspace;
if (!PWORKSPACE) if (!PWORKSPACE)
return box; return box;
const auto WORKSPACEOFFSET = PWORKSPACE && !m_pWindow->m_pinned ? PWORKSPACE->m_renderOffset->value() : Vector2D(); const auto WORKSPACEOFFSET = PWORKSPACE && !m_window->m_pinned ? PWORKSPACE->m_renderOffset->value() : Vector2D();
return box.translate(WORKSPACEOFFSET); return box.translate(WORKSPACEOFFSET);
} }
@ -49,30 +49,30 @@ void CHyprBorderDecoration::draw(PHLMONITOR pMonitor, float const& a) {
if (doesntWantBorders()) if (doesntWantBorders())
return; return;
if (m_bAssignedGeometry.width < m_seExtents.topLeft.x + 1 || m_bAssignedGeometry.height < m_seExtents.topLeft.y + 1) if (m_assignedGeometry.width < m_extents.topLeft.x + 1 || m_assignedGeometry.height < m_extents.topLeft.y + 1)
return; return;
CBox windowBox = assignedBoxGlobal().translate(-pMonitor->m_position + m_pWindow->m_floatingOffset).expand(-m_pWindow->getRealBorderSize()).scale(pMonitor->m_scale).round(); CBox windowBox = assignedBoxGlobal().translate(-pMonitor->m_position + m_window->m_floatingOffset).expand(-m_window->getRealBorderSize()).scale(pMonitor->m_scale).round();
if (windowBox.width < 1 || windowBox.height < 1) if (windowBox.width < 1 || windowBox.height < 1)
return; return;
auto grad = m_pWindow->m_realBorderColor; auto grad = m_window->m_realBorderColor;
const bool ANIMATED = m_pWindow->m_borderFadeAnimationProgress->isBeingAnimated(); const bool ANIMATED = m_window->m_borderFadeAnimationProgress->isBeingAnimated();
if (m_pWindow->m_borderAngleAnimationProgress->enabled()) { if (m_window->m_borderAngleAnimationProgress->enabled()) {
grad.m_angle += m_pWindow->m_borderAngleAnimationProgress->value() * M_PI * 2; grad.m_angle += m_window->m_borderAngleAnimationProgress->value() * M_PI * 2;
grad.m_angle = normalizeAngleRad(grad.m_angle); grad.m_angle = normalizeAngleRad(grad.m_angle);
// When borderangle is animated, it is counterintuitive to fade between inactive/active gradient angles. // When borderangle is animated, it is counterintuitive to fade between inactive/active gradient angles.
// Instead we sync the angles to avoid fading between them and additionally rotating the border angle. // Instead we sync the angles to avoid fading between them and additionally rotating the border angle.
if (ANIMATED) if (ANIMATED)
m_pWindow->m_realBorderColorPrevious.m_angle = grad.m_angle; m_window->m_realBorderColorPrevious.m_angle = grad.m_angle;
} }
int borderSize = m_pWindow->getRealBorderSize(); int borderSize = m_window->getRealBorderSize();
const auto ROUNDING = m_pWindow->rounding() * pMonitor->m_scale; const auto ROUNDING = m_window->rounding() * pMonitor->m_scale;
const auto ROUNDINGPOWER = m_pWindow->roundingPower(); const auto ROUNDINGPOWER = m_window->roundingPower();
CBorderPassElement::SBorderData data; CBorderPassElement::SBorderData data;
data.box = windowBox; data.box = windowBox;
@ -84,12 +84,12 @@ void CHyprBorderDecoration::draw(PHLMONITOR pMonitor, float const& a) {
if (ANIMATED) { if (ANIMATED) {
data.hasGrad2 = true; data.hasGrad2 = true;
data.grad1 = m_pWindow->m_realBorderColorPrevious; data.grad1 = m_window->m_realBorderColorPrevious;
data.grad2 = grad; data.grad2 = grad;
data.lerp = m_pWindow->m_borderFadeAnimationProgress->value(); data.lerp = m_window->m_borderFadeAnimationProgress->value();
} }
g_pHyprRenderer->m_sRenderPass.add(makeShared<CBorderPassElement>(data)); g_pHyprRenderer->m_renderPass.add(makeShared<CBorderPassElement>(data));
} }
eDecorationType CHyprBorderDecoration::getDecorationType() { eDecorationType CHyprBorderDecoration::getDecorationType() {
@ -97,32 +97,32 @@ eDecorationType CHyprBorderDecoration::getDecorationType() {
} }
void CHyprBorderDecoration::updateWindow(PHLWINDOW) { void CHyprBorderDecoration::updateWindow(PHLWINDOW) {
auto borderSize = m_pWindow->getRealBorderSize(); auto borderSize = m_window->getRealBorderSize();
if (borderSize == m_iLastBorderSize) if (borderSize == m_lastBorderSize)
return; return;
if (borderSize <= 0 && m_iLastBorderSize <= 0) if (borderSize <= 0 && m_lastBorderSize <= 0)
return; return;
m_iLastBorderSize = borderSize; m_lastBorderSize = borderSize;
g_pDecorationPositioner->repositionDeco(this); g_pDecorationPositioner->repositionDeco(this);
} }
void CHyprBorderDecoration::damageEntire() { void CHyprBorderDecoration::damageEntire() {
if (!validMapped(m_pWindow)) if (!validMapped(m_window))
return; return;
auto surfaceBox = m_pWindow->getWindowMainSurfaceBox(); auto surfaceBox = m_window->getWindowMainSurfaceBox();
const auto ROUNDING = m_pWindow->rounding(); const auto ROUNDING = m_window->rounding();
const auto ROUNDINGSIZE = ROUNDING - M_SQRT1_2 * ROUNDING + 2; const auto ROUNDINGSIZE = ROUNDING - M_SQRT1_2 * ROUNDING + 2;
const auto BORDERSIZE = m_pWindow->getRealBorderSize() + 1; const auto BORDERSIZE = m_window->getRealBorderSize() + 1;
const auto PWINDOWWORKSPACE = m_pWindow->m_workspace; const auto PWINDOWWORKSPACE = m_window->m_workspace;
if (PWINDOWWORKSPACE && PWINDOWWORKSPACE->m_renderOffset->isBeingAnimated() && !m_pWindow->m_pinned) if (PWINDOWWORKSPACE && PWINDOWWORKSPACE->m_renderOffset->isBeingAnimated() && !m_window->m_pinned)
surfaceBox.translate(PWINDOWWORKSPACE->m_renderOffset->value()); surfaceBox.translate(PWINDOWWORKSPACE->m_renderOffset->value());
surfaceBox.translate(m_pWindow->m_floatingOffset); surfaceBox.translate(m_window->m_floatingOffset);
CBox surfaceBoxExpandedBorder = surfaceBox; CBox surfaceBoxExpandedBorder = surfaceBox;
surfaceBoxExpandedBorder.expand(BORDERSIZE); surfaceBoxExpandedBorder.expand(BORDERSIZE);
@ -133,7 +133,7 @@ void CHyprBorderDecoration::damageEntire() {
borderRegion.subtract(surfaceBoxShrunkRounding); borderRegion.subtract(surfaceBoxShrunkRounding);
for (auto const& m : g_pCompositor->m_monitors) { for (auto const& m : g_pCompositor->m_monitors) {
if (!g_pHyprRenderer->shouldRenderWindow(m_pWindow.lock(), m)) { if (!g_pHyprRenderer->shouldRenderWindow(m_window.lock(), m)) {
const CRegion monitorRegion({m->m_position, m->m_size}); const CRegion monitorRegion({m->m_position, m->m_size});
borderRegion.subtract(monitorRegion); borderRegion.subtract(monitorRegion);
} }
@ -157,5 +157,5 @@ std::string CHyprBorderDecoration::getDisplayName() {
} }
bool CHyprBorderDecoration::doesntWantBorders() { bool CHyprBorderDecoration::doesntWantBorders() {
return m_pWindow->m_windowData.noBorder.valueOrDefault() || m_pWindow->m_X11DoesntWantBorders || m_pWindow->getRealBorderSize() == 0; return m_window->m_windowData.noBorder.valueOrDefault() || m_window->m_X11DoesntWantBorders || m_window->getRealBorderSize() == 0;
} }

13
src/render/decorations/CHyprBorderDecoration.hpp
View File

@ -26,17 +26,14 @@ class CHyprBorderDecoration : public IHyprWindowDecoration {
virtual std::string getDisplayName(); virtual std::string getDisplayName();
private: private:
SBoxExtents m_seExtents; SBoxExtents m_extents;
SBoxExtents m_seReportedExtents; SBoxExtents m_reportedExtents;
PHLWINDOWREF m_pWindow; PHLWINDOWREF m_window;
Vector2D m_vLastWindowPos; CBox m_assignedGeometry = {0};
Vector2D m_vLastWindowSize;
CBox m_bAssignedGeometry = {0}; int m_lastBorderSize = -1;
int m_iLastBorderSize = -1;
CBox assignedBoxGlobal(); CBox assignedBoxGlobal();
bool doesntWantBorders(); bool doesntWantBorders();

66
src/render/decorations/CHyprDropShadowDecoration.cpp
View File

@ -5,7 +5,7 @@
#include "../pass/ShadowPassElement.hpp" #include "../pass/ShadowPassElement.hpp"
#include "../Renderer.hpp" #include "../Renderer.hpp"
CHyprDropShadowDecoration::CHyprDropShadowDecoration(PHLWINDOW pWindow) : IHyprWindowDecoration(pWindow), m_pWindow(pWindow) { CHyprDropShadowDecoration::CHyprDropShadowDecoration(PHLWINDOW pWindow) : IHyprWindowDecoration(pWindow), m_window(pWindow) {
; ;
} }
@ -16,15 +16,15 @@ eDecorationType CHyprDropShadowDecoration::getDecorationType() {
SDecorationPositioningInfo CHyprDropShadowDecoration::getPositioningInfo() { SDecorationPositioningInfo CHyprDropShadowDecoration::getPositioningInfo() {
SDecorationPositioningInfo info; SDecorationPositioningInfo info;
info.policy = DECORATION_POSITION_ABSOLUTE; info.policy = DECORATION_POSITION_ABSOLUTE;
info.desiredExtents = m_seExtents; info.desiredExtents = m_extents;
info.edges = DECORATION_EDGE_BOTTOM | DECORATION_EDGE_LEFT | DECORATION_EDGE_RIGHT | DECORATION_EDGE_TOP; info.edges = DECORATION_EDGE_BOTTOM | DECORATION_EDGE_LEFT | DECORATION_EDGE_RIGHT | DECORATION_EDGE_TOP;
m_seReportedExtents = m_seExtents; m_reportedExtents = m_extents;
return info; return info;
} }
void CHyprDropShadowDecoration::onPositioningReply(const SDecorationPositioningReply& reply) { void CHyprDropShadowDecoration::onPositioningReply(const SDecorationPositioningReply& reply) {
updateWindow(m_pWindow.lock()); updateWindow(m_window.lock());
} }
uint64_t CHyprDropShadowDecoration::getDecorationFlags() { uint64_t CHyprDropShadowDecoration::getDecorationFlags() {
@ -41,11 +41,11 @@ void CHyprDropShadowDecoration::damageEntire() {
if (*PSHADOWS != 1) if (*PSHADOWS != 1)
return; // disabled return; // disabled
const auto PWINDOW = m_pWindow.lock(); const auto PWINDOW = m_window.lock();
CBox shadowBox = {PWINDOW->m_realPosition->value().x - m_seExtents.topLeft.x, PWINDOW->m_realPosition->value().y - m_seExtents.topLeft.y, CBox shadowBox = {PWINDOW->m_realPosition->value().x - m_extents.topLeft.x, PWINDOW->m_realPosition->value().y - m_extents.topLeft.y,
PWINDOW->m_realSize->value().x + m_seExtents.topLeft.x + m_seExtents.bottomRight.x, PWINDOW->m_realSize->value().x + m_extents.topLeft.x + m_extents.bottomRight.x,
PWINDOW->m_realSize->value().y + m_seExtents.topLeft.y + m_seExtents.bottomRight.y}; PWINDOW->m_realSize->value().y + m_extents.topLeft.y + m_extents.bottomRight.y};
const auto PWORKSPACE = PWINDOW->m_workspace; const auto PWORKSPACE = PWINDOW->m_workspace;
if (PWORKSPACE && PWORKSPACE->m_renderOffset->isBeingAnimated() && !PWINDOW->m_pinned) if (PWORKSPACE && PWORKSPACE->m_renderOffset->isBeingAnimated() && !PWINDOW->m_pinned)
@ -77,24 +77,24 @@ void CHyprDropShadowDecoration::damageEntire() {
} }
void CHyprDropShadowDecoration::updateWindow(PHLWINDOW pWindow) { void CHyprDropShadowDecoration::updateWindow(PHLWINDOW pWindow) {
const auto PWINDOW = m_pWindow.lock(); const auto PWINDOW = m_window.lock();
m_vLastWindowPos = PWINDOW->m_realPosition->value(); m_lastWindowPos = PWINDOW->m_realPosition->value();
m_vLastWindowSize = PWINDOW->m_realSize->value(); m_lastWindowSize = PWINDOW->m_realSize->value();
m_bLastWindowBox = {m_vLastWindowPos.x, m_vLastWindowPos.y, m_vLastWindowSize.x, m_vLastWindowSize.y}; m_lastWindowBox = {m_lastWindowPos.x, m_lastWindowPos.y, m_lastWindowSize.x, m_lastWindowSize.y};
m_bLastWindowBoxWithDecos = g_pDecorationPositioner->getBoxWithIncludedDecos(pWindow); m_lastWindowBoxWithDecos = g_pDecorationPositioner->getBoxWithIncludedDecos(pWindow);
} }
void CHyprDropShadowDecoration::draw(PHLMONITOR pMonitor, float const& a) { void CHyprDropShadowDecoration::draw(PHLMONITOR pMonitor, float const& a) {
CShadowPassElement::SShadowData data; CShadowPassElement::SShadowData data;
data.deco = this; data.deco = this;
data.a = a; data.a = a;
g_pHyprRenderer->m_sRenderPass.add(makeShared<CShadowPassElement>(data)); g_pHyprRenderer->m_renderPass.add(makeShared<CShadowPassElement>(data));
} }
void CHyprDropShadowDecoration::render(PHLMONITOR pMonitor, float const& a) { void CHyprDropShadowDecoration::render(PHLMONITOR pMonitor, float const& a) {
const auto PWINDOW = m_pWindow.lock(); const auto PWINDOW = m_window.lock();
if (!validMapped(PWINDOW)) if (!validMapped(PWINDOW))
return; return;
@ -124,7 +124,7 @@ void CHyprDropShadowDecoration::render(PHLMONITOR pMonitor, float const& a) {
const auto WORKSPACEOFFSET = PWORKSPACE && !PWINDOW->m_pinned ? PWORKSPACE->m_renderOffset->value() : Vector2D(); const auto WORKSPACEOFFSET = PWORKSPACE && !PWINDOW->m_pinned ? PWORKSPACE->m_renderOffset->value() : Vector2D();
// draw the shadow // draw the shadow
CBox fullBox = m_bLastWindowBoxWithDecos; CBox fullBox = m_lastWindowBoxWithDecos;
fullBox.translate(-pMonitor->m_position + WORKSPACEOFFSET); fullBox.translate(-pMonitor->m_position + WORKSPACEOFFSET);
fullBox.x -= *PSHADOWSIZE; fullBox.x -= *PSHADOWSIZE;
fullBox.y -= *PSHADOWSIZE; fullBox.y -= *PSHADOWSIZE;
@ -137,10 +137,10 @@ void CHyprDropShadowDecoration::render(PHLMONITOR pMonitor, float const& a) {
fullBox.scaleFromCenter(SHADOWSCALE).translate({(*PSHADOWOFFSET).x, (*PSHADOWOFFSET).y}); fullBox.scaleFromCenter(SHADOWSCALE).translate({(*PSHADOWOFFSET).x, (*PSHADOWOFFSET).y});
updateWindow(PWINDOW); updateWindow(PWINDOW);
m_vLastWindowPos += WORKSPACEOFFSET; m_lastWindowPos += WORKSPACEOFFSET;
m_seExtents = {{m_vLastWindowPos.x - fullBox.x - pMonitor->m_position.x + 2, m_vLastWindowPos.y - fullBox.y - pMonitor->m_position.y + 2}, m_extents = {{m_lastWindowPos.x - fullBox.x - pMonitor->m_position.x + 2, m_lastWindowPos.y - fullBox.y - pMonitor->m_position.y + 2},
{fullBox.x + fullBox.width + pMonitor->m_position.x - m_vLastWindowPos.x - m_vLastWindowSize.x + 2, {fullBox.x + fullBox.width + pMonitor->m_position.x - m_lastWindowPos.x - m_lastWindowSize.x + 2,
fullBox.y + fullBox.height + pMonitor->m_position.y - m_vLastWindowPos.y - m_vLastWindowSize.y + 2}}; fullBox.y + fullBox.height + pMonitor->m_position.y - m_lastWindowPos.y - m_lastWindowSize.y + 2}};
fullBox.translate(PWINDOW->m_floatingOffset); fullBox.translate(PWINDOW->m_floatingOffset);
@ -148,18 +148,18 @@ void CHyprDropShadowDecoration::render(PHLMONITOR pMonitor, float const& a) {
return; // don't draw invisible shadows return; // don't draw invisible shadows
g_pHyprOpenGL->scissor(nullptr); g_pHyprOpenGL->scissor(nullptr);
g_pHyprOpenGL->m_RenderData.currentWindow = m_pWindow; g_pHyprOpenGL->m_renderData.currentWindow = m_window;
// we'll take the liberty of using this as it should not be used rn // we'll take the liberty of using this as it should not be used rn
CFramebuffer& alphaFB = g_pHyprOpenGL->m_RenderData.pCurrentMonData->mirrorFB; CFramebuffer& alphaFB = g_pHyprOpenGL->m_renderData.pCurrentMonData->mirrorFB;
CFramebuffer& alphaSwapFB = g_pHyprOpenGL->m_RenderData.pCurrentMonData->mirrorSwapFB; CFramebuffer& alphaSwapFB = g_pHyprOpenGL->m_renderData.pCurrentMonData->mirrorSwapFB;
auto* LASTFB = g_pHyprOpenGL->m_RenderData.currentFB; auto* LASTFB = g_pHyprOpenGL->m_renderData.currentFB;
fullBox.scale(pMonitor->m_scale).round(); fullBox.scale(pMonitor->m_scale).round();
if (*PSHADOWIGNOREWINDOW) { if (*PSHADOWIGNOREWINDOW) {
CBox windowBox = m_bLastWindowBox; CBox windowBox = m_lastWindowBox;
CBox withDecos = m_bLastWindowBoxWithDecos; CBox withDecos = m_lastWindowBoxWithDecos;
// get window box // get window box
windowBox.translate(-pMonitor->m_position + WORKSPACEOFFSET); windowBox.translate(-pMonitor->m_position + WORKSPACEOFFSET);
@ -178,11 +178,11 @@ void CHyprDropShadowDecoration::render(PHLMONITOR pMonitor, float const& a) {
if (windowBox.width < 1 || windowBox.height < 1) if (windowBox.width < 1 || windowBox.height < 1)
return; // prevent assert failed return; // prevent assert failed
CRegion saveDamage = g_pHyprOpenGL->m_RenderData.damage; CRegion saveDamage = g_pHyprOpenGL->m_renderData.damage;
g_pHyprOpenGL->m_RenderData.damage = fullBox; g_pHyprOpenGL->m_renderData.damage = fullBox;
g_pHyprOpenGL->m_RenderData.damage.subtract(windowBox.copy().expand(-ROUNDING * pMonitor->m_scale)).intersect(saveDamage); g_pHyprOpenGL->m_renderData.damage.subtract(windowBox.copy().expand(-ROUNDING * pMonitor->m_scale)).intersect(saveDamage);
g_pHyprOpenGL->m_RenderData.renderModif.applyToRegion(g_pHyprOpenGL->m_RenderData.damage); g_pHyprOpenGL->m_renderData.renderModif.applyToRegion(g_pHyprOpenGL->m_renderData.damage);
alphaFB.bind(); alphaFB.bind();
@ -212,14 +212,14 @@ void CHyprDropShadowDecoration::render(PHLMONITOR pMonitor, float const& a) {
g_pHyprOpenGL->setRenderModifEnabled(true); g_pHyprOpenGL->setRenderModifEnabled(true);
g_pHyprOpenGL->setMonitorTransformEnabled(false); g_pHyprOpenGL->setMonitorTransformEnabled(false);
g_pHyprOpenGL->m_RenderData.damage = saveDamage; g_pHyprOpenGL->m_renderData.damage = saveDamage;
} else } else
drawShadowInternal(fullBox, ROUNDING * pMonitor->m_scale, ROUNDINGPOWER, *PSHADOWSIZE * pMonitor->m_scale, PWINDOW->m_realShadowColor->value(), a); drawShadowInternal(fullBox, ROUNDING * pMonitor->m_scale, ROUNDINGPOWER, *PSHADOWSIZE * pMonitor->m_scale, PWINDOW->m_realShadowColor->value(), a);
if (m_seExtents != m_seReportedExtents) if (m_extents != m_reportedExtents)
g_pDecorationPositioner->repositionDeco(this); g_pDecorationPositioner->repositionDeco(this);
g_pHyprOpenGL->m_RenderData.currentWindow.reset(); g_pHyprOpenGL->m_renderData.currentWindow.reset();
} }
eDecorationLayer CHyprDropShadowDecoration::getDecorationLayer() { eDecorationLayer CHyprDropShadowDecoration::getDecorationLayer() {

14
src/render/decorations/CHyprDropShadowDecoration.hpp
View File

@ -28,16 +28,16 @@ class CHyprDropShadowDecoration : public IHyprWindowDecoration {
void render(PHLMONITOR, float const& a); void render(PHLMONITOR, float const& a);
private: private:
SBoxExtents m_seExtents; SBoxExtents m_extents;
SBoxExtents m_seReportedExtents; SBoxExtents m_reportedExtents;
PHLWINDOWREF m_pWindow; PHLWINDOWREF m_window;
Vector2D m_vLastWindowPos; Vector2D m_lastWindowPos;
Vector2D m_vLastWindowSize; Vector2D m_lastWindowSize;
void drawShadowInternal(const CBox& box, int round, float roundingPower, int range, CHyprColor color, float a); void drawShadowInternal(const CBox& box, int round, float roundingPower, int range, CHyprColor color, float a);
CBox m_bLastWindowBox = {0}; CBox m_lastWindowBox = {0};
CBox m_bLastWindowBoxWithDecos = {0}; CBox m_lastWindowBoxWithDecos = {0};
}; };

136
src/render/decorations/CHyprGroupBarDecoration.cpp
View File

@ -17,11 +17,11 @@ static SP<CTexture> m_tGradientLockedInactive = makeShared<CTexture>();
constexpr int BAR_TEXT_PAD = 2; constexpr int BAR_TEXT_PAD = 2;
CHyprGroupBarDecoration::CHyprGroupBarDecoration(PHLWINDOW pWindow) : IHyprWindowDecoration(pWindow), m_pWindow(pWindow) { CHyprGroupBarDecoration::CHyprGroupBarDecoration(PHLWINDOW pWindow) : IHyprWindowDecoration(pWindow), m_window(pWindow) {
static auto PGRADIENTS = CConfigValue<Hyprlang::INT>("group:groupbar:enabled"); static auto PGRADIENTS = CConfigValue<Hyprlang::INT>("group:groupbar:enabled");
static auto PENABLED = CConfigValue<Hyprlang::INT>("group:groupbar:gradients"); static auto PENABLED = CConfigValue<Hyprlang::INT>("group:groupbar:gradients");
if (m_tGradientActive->m_iTexID == 0 && *PENABLED && *PGRADIENTS) if (m_tGradientActive->m_texID == 0 && *PENABLED && *PGRADIENTS)
refreshGroupBarGradients(); refreshGroupBarGradients();
} }
@ -43,7 +43,7 @@ SDecorationPositioningInfo CHyprGroupBarDecoration::getPositioningInfo() {
info.priority = *PPRIORITY; info.priority = *PPRIORITY;
info.reserved = true; info.reserved = true;
if (*PENABLED && m_pWindow->m_windowData.decorate.valueOrDefault()) { if (*PENABLED && m_window->m_windowData.decorate.valueOrDefault()) {
if (*PSTACKED) { if (*PSTACKED) {
const auto ONEBARHEIGHT = *POUTERGAP + *PINDICATORHEIGHT + *PINDICATORGAP + (*PGRADIENTS || *PRENDERTITLES ? *PHEIGHT : 0); const auto ONEBARHEIGHT = *POUTERGAP + *PINDICATORHEIGHT + *PINDICATORGAP + (*PGRADIENTS || *PRENDERTITLES ? *PHEIGHT : 0);
info.desiredExtents = {{0, (ONEBARHEIGHT * m_dwGroupMembers.size()) + (*PKEEPUPPERGAP * *POUTERGAP)}, {0, 0}}; info.desiredExtents = {{0, (ONEBARHEIGHT * m_dwGroupMembers.size()) + (*PKEEPUPPERGAP * *POUTERGAP)}, {0, 0}};
@ -55,7 +55,7 @@ SDecorationPositioningInfo CHyprGroupBarDecoration::getPositioningInfo() {
} }
void CHyprGroupBarDecoration::onPositioningReply(const SDecorationPositioningReply& reply) { void CHyprGroupBarDecoration::onPositioningReply(const SDecorationPositioningReply& reply) {
m_bAssignedBox = reply.assignedGeometry; m_assignedBox = reply.assignedGeometry;
} }
eDecorationType CHyprGroupBarDecoration::getDecorationType() { eDecorationType CHyprGroupBarDecoration::getDecorationType() {
@ -65,8 +65,8 @@ eDecorationType CHyprGroupBarDecoration::getDecorationType() {
// //
void CHyprGroupBarDecoration::updateWindow(PHLWINDOW pWindow) { void CHyprGroupBarDecoration::updateWindow(PHLWINDOW pWindow) {
if (m_pWindow->m_groupData.pNextWindow.expired()) { if (m_window->m_groupData.pNextWindow.expired()) {
m_pWindow->removeWindowDeco(this); m_window->removeWindowDeco(this);
return; return;
} }
@ -83,14 +83,14 @@ void CHyprGroupBarDecoration::updateWindow(PHLWINDOW pWindow) {
damageEntire(); damageEntire();
if (m_dwGroupMembers.size() == 0) { if (m_dwGroupMembers.size() == 0) {
m_pWindow->removeWindowDeco(this); m_window->removeWindowDeco(this);
return; return;
} }
} }
void CHyprGroupBarDecoration::damageEntire() { void CHyprGroupBarDecoration::damageEntire() {
auto box = assignedBoxGlobal(); auto box = assignedBoxGlobal();
box.translate(m_pWindow->m_floatingOffset); box.translate(m_window->m_floatingOffset);
g_pHyprRenderer->damageBox(box); g_pHyprRenderer->damageBox(box);
} }
@ -100,7 +100,7 @@ void CHyprGroupBarDecoration::draw(PHLMONITOR pMonitor, float const& a) {
static auto PENABLED = CConfigValue<Hyprlang::INT>("group:groupbar:enabled"); static auto PENABLED = CConfigValue<Hyprlang::INT>("group:groupbar:enabled");
if (!*PENABLED || !m_pWindow->m_windowData.decorate.valueOrDefault()) if (!*PENABLED || !m_window->m_windowData.decorate.valueOrDefault())
return; return;
static auto PRENDERTITLES = CConfigValue<Hyprlang::INT>("group:groupbar:render_titles"); static auto PRENDERTITLES = CConfigValue<Hyprlang::INT>("group:groupbar:render_titles");
@ -130,8 +130,8 @@ void CHyprGroupBarDecoration::draw(PHLMONITOR pMonitor, float const& a) {
const auto ASSIGNEDBOX = assignedBoxGlobal(); const auto ASSIGNEDBOX = assignedBoxGlobal();
const auto ONEBARHEIGHT = *POUTERGAP + *PINDICATORHEIGHT + *PINDICATORGAP + (*PGRADIENTS || *PRENDERTITLES ? *PHEIGHT : 0); const auto ONEBARHEIGHT = *POUTERGAP + *PINDICATORHEIGHT + *PINDICATORGAP + (*PGRADIENTS || *PRENDERTITLES ? *PHEIGHT : 0);
m_fBarWidth = *PSTACKED ? ASSIGNEDBOX.w : (ASSIGNEDBOX.w - *PINNERGAP * (barsToDraw - 1)) / barsToDraw; m_barWidth = *PSTACKED ? ASSIGNEDBOX.w : (ASSIGNEDBOX.w - *PINNERGAP * (barsToDraw - 1)) / barsToDraw;
m_fBarHeight = *PSTACKED ? ((ASSIGNEDBOX.h - *POUTERGAP * *PKEEPUPPERGAP) - *POUTERGAP * (barsToDraw)) / barsToDraw : ASSIGNEDBOX.h - *POUTERGAP * *PKEEPUPPERGAP; m_barHeight = *PSTACKED ? ((ASSIGNEDBOX.h - *POUTERGAP * *PKEEPUPPERGAP) - *POUTERGAP * (barsToDraw)) / barsToDraw : ASSIGNEDBOX.h - *POUTERGAP * *PKEEPUPPERGAP;
const auto DESIREDHEIGHT = *PSTACKED ? (ONEBARHEIGHT * m_dwGroupMembers.size()) + *POUTERGAP * *PKEEPUPPERGAP : *POUTERGAP * (1 + *PKEEPUPPERGAP) + ONEBARHEIGHT; const auto DESIREDHEIGHT = *PSTACKED ? (ONEBARHEIGHT * m_dwGroupMembers.size()) + *POUTERGAP * *PKEEPUPPERGAP : *POUTERGAP * (1 + *PKEEPUPPERGAP) + ONEBARHEIGHT;
if (DESIREDHEIGHT != ASSIGNEDBOX.h) if (DESIREDHEIGHT != ASSIGNEDBOX.h)
@ -143,13 +143,13 @@ void CHyprGroupBarDecoration::draw(PHLMONITOR pMonitor, float const& a) {
for (int i = 0; i < barsToDraw; ++i) { for (int i = 0; i < barsToDraw; ++i) {
const auto WINDOWINDEX = *PSTACKED ? m_dwGroupMembers.size() - i - 1 : i; const auto WINDOWINDEX = *PSTACKED ? m_dwGroupMembers.size() - i - 1 : i;
CBox rect = {ASSIGNEDBOX.x + xoff - pMonitor->m_position.x + m_pWindow->m_floatingOffset.x, CBox rect = {ASSIGNEDBOX.x + xoff - pMonitor->m_position.x + m_window->m_floatingOffset.x,
ASSIGNEDBOX.y + ASSIGNEDBOX.h - floor(yoff) - *PINDICATORHEIGHT - *POUTERGAP - pMonitor->m_position.y + m_pWindow->m_floatingOffset.y, m_fBarWidth, ASSIGNEDBOX.y + ASSIGNEDBOX.h - floor(yoff) - *PINDICATORHEIGHT - *POUTERGAP - pMonitor->m_position.y + m_window->m_floatingOffset.y, m_barWidth,
*PINDICATORHEIGHT}; *PINDICATORHEIGHT};
rect.scale(pMonitor->m_scale).round(); rect.scale(pMonitor->m_scale).round();
const bool GROUPLOCKED = m_pWindow->getGroupHead()->m_groupData.locked || g_pKeybindManager->m_groupsLocked; const bool GROUPLOCKED = m_window->getGroupHead()->m_groupData.locked || g_pKeybindManager->m_groupsLocked;
const auto* const PCOLACTIVE = GROUPLOCKED ? GROUPCOLACTIVELOCKED : GROUPCOLACTIVE; const auto* const PCOLACTIVE = GROUPLOCKED ? GROUPCOLACTIVELOCKED : GROUPCOLACTIVE;
const auto* const PCOLINACTIVE = GROUPLOCKED ? GROUPCOLINACTIVELOCKED : GROUPCOLINACTIVE; const auto* const PCOLINACTIVE = GROUPLOCKED ? GROUPCOLINACTIVELOCKED : GROUPCOLINACTIVE;
@ -170,25 +170,25 @@ void CHyprGroupBarDecoration::draw(PHLMONITOR pMonitor, float const& a) {
double first = rect.w - (*PROUNDING * 2); double first = rect.w - (*PROUNDING * 2);
rectdata.round = *PROUNDING; rectdata.round = *PROUNDING;
rectdata.clipBox = CBox{rect.pos() - Vector2D{PADDING, 0.F}, Vector2D{first + PADDING, rect.h}}; rectdata.clipBox = CBox{rect.pos() - Vector2D{PADDING, 0.F}, Vector2D{first + PADDING, rect.h}};
g_pHyprRenderer->m_sRenderPass.add(makeShared<CRectPassElement>(rectdata)); g_pHyprRenderer->m_renderPass.add(makeShared<CRectPassElement>(rectdata));
rectdata.round = 0; rectdata.round = 0;
rectdata.clipBox = CBox{rect.pos() + Vector2D{first, 0.F}, Vector2D{rect.w - first + PADDING, rect.h}}; rectdata.clipBox = CBox{rect.pos() + Vector2D{first, 0.F}, Vector2D{rect.w - first + PADDING, rect.h}};
} else if (i == barsToDraw - 1) { } else if (i == barsToDraw - 1) {
double first = *PROUNDING * 2; double first = *PROUNDING * 2;
rectdata.round = 0; rectdata.round = 0;
rectdata.clipBox = CBox{rect.pos() - Vector2D{PADDING, 0.F}, Vector2D{first + PADDING, rect.h}}; rectdata.clipBox = CBox{rect.pos() - Vector2D{PADDING, 0.F}, Vector2D{first + PADDING, rect.h}};
g_pHyprRenderer->m_sRenderPass.add(makeShared<CRectPassElement>(rectdata)); g_pHyprRenderer->m_renderPass.add(makeShared<CRectPassElement>(rectdata));
rectdata.round = *PROUNDING; rectdata.round = *PROUNDING;
rectdata.clipBox = CBox{rect.pos() + Vector2D{first, 0.F}, Vector2D{rect.w - first + PADDING, rect.h}}; rectdata.clipBox = CBox{rect.pos() + Vector2D{first, 0.F}, Vector2D{rect.w - first + PADDING, rect.h}};
} }
} else } else
rectdata.round = *PROUNDING; rectdata.round = *PROUNDING;
} }
g_pHyprRenderer->m_sRenderPass.add(makeShared<CRectPassElement>(rectdata)); g_pHyprRenderer->m_renderPass.add(makeShared<CRectPassElement>(rectdata));
} }
rect = {ASSIGNEDBOX.x + xoff - pMonitor->m_position.x + m_pWindow->m_floatingOffset.x, rect = {ASSIGNEDBOX.x + xoff - pMonitor->m_position.x + m_window->m_floatingOffset.x,
ASSIGNEDBOX.y + ASSIGNEDBOX.h - floor(yoff) - ONEBARHEIGHT - pMonitor->m_position.y + m_pWindow->m_floatingOffset.y, m_fBarWidth, ASSIGNEDBOX.y + ASSIGNEDBOX.h - floor(yoff) - ONEBARHEIGHT - pMonitor->m_position.y + m_window->m_floatingOffset.y, m_barWidth,
(*PGRADIENTS || *PRENDERTITLES ? *PHEIGHT : 0)}; (*PGRADIENTS || *PRENDERTITLES ? *PHEIGHT : 0)};
rect.scale(pMonitor->m_scale); rect.scale(pMonitor->m_scale);
@ -196,7 +196,7 @@ void CHyprGroupBarDecoration::draw(PHLMONITOR pMonitor, float const& a) {
if (*PGRADIENTS) { if (*PGRADIENTS) {
const auto GRADIENTTEX = (m_dwGroupMembers[WINDOWINDEX] == g_pCompositor->m_lastWindow ? (GROUPLOCKED ? m_tGradientLockedActive : m_tGradientActive) : const auto GRADIENTTEX = (m_dwGroupMembers[WINDOWINDEX] == g_pCompositor->m_lastWindow ? (GROUPLOCKED ? m_tGradientLockedActive : m_tGradientActive) :
(GROUPLOCKED ? m_tGradientLockedInactive : m_tGradientInactive)); (GROUPLOCKED ? m_tGradientLockedInactive : m_tGradientInactive));
if (GRADIENTTEX->m_iTexID) { if (GRADIENTTEX->m_texID) {
CTexPassElement::SRenderData data; CTexPassElement::SRenderData data;
data.tex = GRADIENTTEX; data.tex = GRADIENTTEX;
data.box = rect; data.box = rect;
@ -210,21 +210,21 @@ void CHyprGroupBarDecoration::draw(PHLMONITOR pMonitor, float const& a) {
double first = rect.w - (*PGRADIENTROUNDING * 2); double first = rect.w - (*PGRADIENTROUNDING * 2);
data.round = *PGRADIENTROUNDING; data.round = *PGRADIENTROUNDING;
data.clipBox = CBox{rect.pos() - Vector2D{PADDING, 0.F}, Vector2D{first + PADDING, rect.h}}; data.clipBox = CBox{rect.pos() - Vector2D{PADDING, 0.F}, Vector2D{first + PADDING, rect.h}};
g_pHyprRenderer->m_sRenderPass.add(makeShared<CTexPassElement>(data)); g_pHyprRenderer->m_renderPass.add(makeShared<CTexPassElement>(data));
data.round = 0; data.round = 0;
data.clipBox = CBox{rect.pos() + Vector2D{first, 0.F}, Vector2D{rect.w - first + PADDING, rect.h}}; data.clipBox = CBox{rect.pos() + Vector2D{first, 0.F}, Vector2D{rect.w - first + PADDING, rect.h}};
} else if (i == barsToDraw - 1) { } else if (i == barsToDraw - 1) {
double first = *PGRADIENTROUNDING * 2; double first = *PGRADIENTROUNDING * 2;
data.round = 0; data.round = 0;
data.clipBox = CBox{rect.pos() - Vector2D{PADDING, 0.F}, Vector2D{first + PADDING, rect.h}}; data.clipBox = CBox{rect.pos() - Vector2D{PADDING, 0.F}, Vector2D{first + PADDING, rect.h}};
g_pHyprRenderer->m_sRenderPass.add(makeShared<CTexPassElement>(data)); g_pHyprRenderer->m_renderPass.add(makeShared<CTexPassElement>(data));
data.round = *PGRADIENTROUNDING; data.round = *PGRADIENTROUNDING;
data.clipBox = CBox{rect.pos() + Vector2D{first, 0.F}, Vector2D{rect.w - first + PADDING, rect.h}}; data.clipBox = CBox{rect.pos() + Vector2D{first, 0.F}, Vector2D{rect.w - first + PADDING, rect.h}};
} }
} else } else
data.round = *PGRADIENTROUNDING; data.round = *PGRADIENTROUNDING;
} }
g_pHyprRenderer->m_sRenderPass.add(makeShared<CTexPassElement>(data)); g_pHyprRenderer->m_renderPass.add(makeShared<CTexPassElement>(data));
} }
} }
@ -232,31 +232,31 @@ void CHyprGroupBarDecoration::draw(PHLMONITOR pMonitor, float const& a) {
CTitleTex* pTitleTex = textureFromTitle(m_dwGroupMembers[WINDOWINDEX]->m_title); CTitleTex* pTitleTex = textureFromTitle(m_dwGroupMembers[WINDOWINDEX]->m_title);
if (!pTitleTex) if (!pTitleTex)
pTitleTex = m_sTitleTexs.titleTexs pTitleTex = m_titleTexs.titleTexs
.emplace_back(makeUnique<CTitleTex>(m_dwGroupMembers[WINDOWINDEX].lock(), .emplace_back(makeUnique<CTitleTex>(m_dwGroupMembers[WINDOWINDEX].lock(),
Vector2D{m_fBarWidth * pMonitor->m_scale, (*PTITLEFONTSIZE + 2L * BAR_TEXT_PAD) * pMonitor->m_scale}, Vector2D{m_barWidth * pMonitor->m_scale, (*PTITLEFONTSIZE + 2L * BAR_TEXT_PAD) * pMonitor->m_scale},
pMonitor->m_scale)) pMonitor->m_scale))
.get(); .get();
const auto titleTex = m_dwGroupMembers[WINDOWINDEX] == g_pCompositor->m_lastWindow ? pTitleTex->texActive : pTitleTex->texInactive; const auto titleTex = m_dwGroupMembers[WINDOWINDEX] == g_pCompositor->m_lastWindow ? pTitleTex->m_texActive : pTitleTex->m_texInactive;
rect.y += std::ceil(((rect.height - titleTex->m_vSize.y) / 2.0) - (*PTEXTOFFSET * pMonitor->m_scale)); rect.y += std::ceil(((rect.height - titleTex->m_size.y) / 2.0) - (*PTEXTOFFSET * pMonitor->m_scale));
rect.height = titleTex->m_vSize.y; rect.height = titleTex->m_size.y;
rect.width = titleTex->m_vSize.x; rect.width = titleTex->m_size.x;
rect.x += std::round(((m_fBarWidth * pMonitor->m_scale) / 2.0) - (titleTex->m_vSize.x / 2.0)); rect.x += std::round(((m_barWidth * pMonitor->m_scale) / 2.0) - (titleTex->m_size.x / 2.0));
rect.round(); rect.round();
CTexPassElement::SRenderData data; CTexPassElement::SRenderData data;
data.tex = titleTex; data.tex = titleTex;
data.box = rect; data.box = rect;
data.a = a; data.a = a;
g_pHyprRenderer->m_sRenderPass.add(makeShared<CTexPassElement>(data)); g_pHyprRenderer->m_renderPass.add(makeShared<CTexPassElement>(data));
} }
} }
if (*PSTACKED) if (*PSTACKED)
yoff += ONEBARHEIGHT; yoff += ONEBARHEIGHT;
else else
xoff += *PINNERGAP + m_fBarWidth; xoff += *PINNERGAP + m_barWidth;
} }
if (*PRENDERTITLES) if (*PRENDERTITLES)
@ -264,8 +264,8 @@ void CHyprGroupBarDecoration::draw(PHLMONITOR pMonitor, float const& a) {
} }
CTitleTex* CHyprGroupBarDecoration::textureFromTitle(const std::string& title) { CTitleTex* CHyprGroupBarDecoration::textureFromTitle(const std::string& title) {
for (auto const& tex : m_sTitleTexs.titleTexs) { for (auto const& tex : m_titleTexs.titleTexs) {
if (tex->szContent == title) if (tex->m_content == title)
return tex.get(); return tex.get();
} }
@ -273,10 +273,10 @@ CTitleTex* CHyprGroupBarDecoration::textureFromTitle(const std::string& title) {
} }
void CHyprGroupBarDecoration::invalidateTextures() { void CHyprGroupBarDecoration::invalidateTextures() {
m_sTitleTexs.titleTexs.clear(); m_titleTexs.titleTexs.clear();
} }
CTitleTex::CTitleTex(PHLWINDOW pWindow, const Vector2D& bufferSize, const float monitorScale) : szContent(pWindow->m_title), pWindowOwner(pWindow) { CTitleTex::CTitleTex(PHLWINDOW pWindow, const Vector2D& bufferSize, const float monitorScale) : m_content(pWindow->m_title), m_windowOwner(pWindow) {
static auto FALLBACKFONT = CConfigValue<std::string>("misc:font_family"); static auto FALLBACKFONT = CConfigValue<std::string>("misc:font_family");
static auto PTITLEFONTFAMILY = CConfigValue<std::string>("group:groupbar:font_family"); static auto PTITLEFONTFAMILY = CConfigValue<std::string>("group:groupbar:font_family");
static auto PTITLEFONTSIZE = CConfigValue<Hyprlang::INT>("group:groupbar:font_size"); static auto PTITLEFONTSIZE = CConfigValue<Hyprlang::INT>("group:groupbar:font_size");
@ -291,8 +291,8 @@ CTitleTex::CTitleTex(PHLWINDOW pWindow, const Vector2D& bufferSize, const float
const CHyprColor COLOR = CHyprColor(*PTEXTCOLOR); const CHyprColor COLOR = CHyprColor(*PTEXTCOLOR);
const auto FONTFAMILY = *PTITLEFONTFAMILY != STRVAL_EMPTY ? *PTITLEFONTFAMILY : *FALLBACKFONT; const auto FONTFAMILY = *PTITLEFONTFAMILY != STRVAL_EMPTY ? *PTITLEFONTFAMILY : *FALLBACKFONT;
texActive = g_pHyprOpenGL->renderText(pWindow->m_title, COLOR, *PTITLEFONTSIZE * monitorScale, false, FONTFAMILY, bufferSize.x - 2, FONTWEIGHTACTIVE->m_value); m_texActive = g_pHyprOpenGL->renderText(pWindow->m_title, COLOR, *PTITLEFONTSIZE * monitorScale, false, FONTFAMILY, bufferSize.x - 2, FONTWEIGHTACTIVE->m_value);
texInactive = g_pHyprOpenGL->renderText(pWindow->m_title, COLOR, *PTITLEFONTSIZE * monitorScale, false, FONTFAMILY, bufferSize.x - 2, FONTWEIGHTINACTIVE->m_value); m_texInactive = g_pHyprOpenGL->renderText(pWindow->m_title, COLOR, *PTITLEFONTSIZE * monitorScale, false, FONTFAMILY, bufferSize.x - 2, FONTWEIGHTINACTIVE->m_value);
} }
static void renderGradientTo(SP<CTexture> tex, CGradientValueData* grad) { static void renderGradientTo(SP<CTexture> tex, CGradientValueData* grad) {
@ -329,7 +329,7 @@ static void renderGradientTo(SP<CTexture> tex, CGradientValueData* grad) {
// copy the data to an OpenGL texture we have // copy the data to an OpenGL texture we have
const auto DATA = cairo_image_surface_get_data(CAIROSURFACE); const auto DATA = cairo_image_surface_get_data(CAIROSURFACE);
tex->allocate(); tex->allocate();
glBindTexture(GL_TEXTURE_2D, tex->m_iTexID); glBindTexture(GL_TEXTURE_2D, tex->m_texID);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
@ -360,7 +360,7 @@ void refreshGroupBarGradients() {
g_pHyprRenderer->makeEGLCurrent(); g_pHyprRenderer->makeEGLCurrent();
if (m_tGradientActive->m_iTexID != 0) { if (m_tGradientActive->m_texID != 0) {
m_tGradientActive->destroyTexture(); m_tGradientActive->destroyTexture();
m_tGradientInactive->destroyTexture(); m_tGradientInactive->destroyTexture();
m_tGradientLockedActive->destroyTexture(); m_tGradientLockedActive->destroyTexture();
@ -380,20 +380,20 @@ bool CHyprGroupBarDecoration::onBeginWindowDragOnDeco(const Vector2D& pos) {
static auto PSTACKED = CConfigValue<Hyprlang::INT>("group:groupbar:stacked"); static auto PSTACKED = CConfigValue<Hyprlang::INT>("group:groupbar:stacked");
static auto POUTERGAP = CConfigValue<Hyprlang::INT>("group:groupbar:gaps_out"); static auto POUTERGAP = CConfigValue<Hyprlang::INT>("group:groupbar:gaps_out");
static auto PINNERGAP = CConfigValue<Hyprlang::INT>("group:groupbar:gaps_in"); static auto PINNERGAP = CConfigValue<Hyprlang::INT>("group:groupbar:gaps_in");
if (m_pWindow.lock() == m_pWindow->m_groupData.pNextWindow.lock()) if (m_window.lock() == m_window->m_groupData.pNextWindow.lock())
return false; return false;
const float BARRELATIVEX = pos.x - assignedBoxGlobal().x; const float BARRELATIVEX = pos.x - assignedBoxGlobal().x;
const float BARRELATIVEY = pos.y - assignedBoxGlobal().y; const float BARRELATIVEY = pos.y - assignedBoxGlobal().y;
const int WINDOWINDEX = *PSTACKED ? (BARRELATIVEY / (m_fBarHeight + *POUTERGAP)) : (BARRELATIVEX) / (m_fBarWidth + *PINNERGAP); const int WINDOWINDEX = *PSTACKED ? (BARRELATIVEY / (m_barHeight + *POUTERGAP)) : (BARRELATIVEX) / (m_barWidth + *PINNERGAP);
if (!*PSTACKED && (BARRELATIVEX - (m_fBarWidth + *PINNERGAP) * WINDOWINDEX > m_fBarWidth)) if (!*PSTACKED && (BARRELATIVEX - (m_barWidth + *PINNERGAP) * WINDOWINDEX > m_barWidth))
return false; return false;
if (*PSTACKED && (BARRELATIVEY - (m_fBarHeight + *POUTERGAP) * WINDOWINDEX < *POUTERGAP)) if (*PSTACKED && (BARRELATIVEY - (m_barHeight + *POUTERGAP) * WINDOWINDEX < *POUTERGAP))
return false; return false;
PHLWINDOW pWindow = m_pWindow->getGroupWindowByIndex(WINDOWINDEX); PHLWINDOW pWindow = m_window->getGroupWindowByIndex(WINDOWINDEX);
// hack // hack
g_pLayoutManager->getCurrentLayout()->onWindowRemoved(pWindow); g_pLayoutManager->getCurrentLayout()->onWindowRemoved(pWindow);
@ -419,21 +419,21 @@ bool CHyprGroupBarDecoration::onEndWindowDragOnDeco(const Vector2D& pos, PHLWIND
static auto PMERGEGROUPSONGROUPBAR = CConfigValue<Hyprlang::INT>("group:merge_groups_on_groupbar"); static auto PMERGEGROUPSONGROUPBAR = CConfigValue<Hyprlang::INT>("group:merge_groups_on_groupbar");
static auto POUTERGAP = CConfigValue<Hyprlang::INT>("group:groupbar:gaps_out"); static auto POUTERGAP = CConfigValue<Hyprlang::INT>("group:groupbar:gaps_out");
static auto PINNERGAP = CConfigValue<Hyprlang::INT>("group:groupbar:gaps_in"); static auto PINNERGAP = CConfigValue<Hyprlang::INT>("group:groupbar:gaps_in");
const bool FLOATEDINTOTILED = !m_pWindow->m_isFloating && !pDraggedWindow->m_draggingTiled; const bool FLOATEDINTOTILED = !m_window->m_isFloating && !pDraggedWindow->m_draggingTiled;
g_pInputManager->m_wasDraggingWindow = false; g_pInputManager->m_wasDraggingWindow = false;
if (!pDraggedWindow->canBeGroupedInto(m_pWindow.lock()) || (*PDRAGINTOGROUP != 1 && *PDRAGINTOGROUP != 2) || (FLOATEDINTOTILED && !*PMERGEFLOATEDINTOTILEDONGROUPBAR) || if (!pDraggedWindow->canBeGroupedInto(m_window.lock()) || (*PDRAGINTOGROUP != 1 && *PDRAGINTOGROUP != 2) || (FLOATEDINTOTILED && !*PMERGEFLOATEDINTOTILEDONGROUPBAR) ||
(!*PMERGEGROUPSONGROUPBAR && pDraggedWindow->m_groupData.pNextWindow.lock() && m_pWindow->m_groupData.pNextWindow.lock())) { (!*PMERGEGROUPSONGROUPBAR && pDraggedWindow->m_groupData.pNextWindow.lock() && m_window->m_groupData.pNextWindow.lock())) {
g_pInputManager->m_wasDraggingWindow = true; g_pInputManager->m_wasDraggingWindow = true;
return false; return false;
} }
const float BARRELATIVE = *PSTACKED ? pos.y - assignedBoxGlobal().y - (m_fBarHeight + *POUTERGAP) / 2 : pos.x - assignedBoxGlobal().x - m_fBarWidth / 2; const float BARRELATIVE = *PSTACKED ? pos.y - assignedBoxGlobal().y - (m_barHeight + *POUTERGAP) / 2 : pos.x - assignedBoxGlobal().x - m_barWidth / 2;
const float BARSIZE = *PSTACKED ? m_fBarHeight + *POUTERGAP : m_fBarWidth + *PINNERGAP; const float BARSIZE = *PSTACKED ? m_barHeight + *POUTERGAP : m_barWidth + *PINNERGAP;
const int WINDOWINDEX = BARRELATIVE < 0 ? -1 : BARRELATIVE / BARSIZE; const int WINDOWINDEX = BARRELATIVE < 0 ? -1 : BARRELATIVE / BARSIZE;
PHLWINDOW pWindowInsertAfter = m_pWindow->getGroupWindowByIndex(WINDOWINDEX); PHLWINDOW pWindowInsertAfter = m_window->getGroupWindowByIndex(WINDOWINDEX);
PHLWINDOW pWindowInsertEnd = pWindowInsertAfter->m_groupData.pNextWindow.lock(); PHLWINDOW pWindowInsertEnd = pWindowInsertAfter->m_groupData.pNextWindow.lock();
PHLWINDOW pDraggedHead = pDraggedWindow->m_groupData.pNextWindow.lock() ? pDraggedWindow->getGroupHead() : pDraggedWindow; PHLWINDOW pDraggedHead = pDraggedWindow->m_groupData.pNextWindow.lock() ? pDraggedWindow->getGroupHead() : pDraggedWindow;
@ -478,7 +478,7 @@ bool CHyprGroupBarDecoration::onEndWindowDragOnDeco(const Vector2D& pos, PHLWIND
if (WINDOWINDEX == -1) if (WINDOWINDEX == -1)
std::swap(pDraggedHead->m_groupData.head, pWindowInsertEnd->m_groupData.head); std::swap(pDraggedHead->m_groupData.head, pWindowInsertEnd->m_groupData.head);
m_pWindow->setGroupCurrent(pDraggedWindow); m_window->setGroupCurrent(pDraggedWindow);
pDraggedWindow->applyGroupRules(); pDraggedWindow->applyGroupRules();
pDraggedWindow->updateWindowDecos(); pDraggedWindow->updateWindowDecos();
g_pLayoutManager->getCurrentLayout()->recalculateWindow(pDraggedWindow); g_pLayoutManager->getCurrentLayout()->recalculateWindow(pDraggedWindow);
@ -493,12 +493,12 @@ bool CHyprGroupBarDecoration::onMouseButtonOnDeco(const Vector2D& pos, const IPo
static auto PSTACKED = CConfigValue<Hyprlang::INT>("group:groupbar:stacked"); static auto PSTACKED = CConfigValue<Hyprlang::INT>("group:groupbar:stacked");
static auto POUTERGAP = CConfigValue<Hyprlang::INT>("group:groupbar:gaps_out"); static auto POUTERGAP = CConfigValue<Hyprlang::INT>("group:groupbar:gaps_out");
static auto PINNERGAP = CConfigValue<Hyprlang::INT>("group:groupbar:gaps_in"); static auto PINNERGAP = CConfigValue<Hyprlang::INT>("group:groupbar:gaps_in");
if (m_pWindow->isEffectiveInternalFSMode(FSMODE_FULLSCREEN)) if (m_window->isEffectiveInternalFSMode(FSMODE_FULLSCREEN))
return true; return true;
const float BARRELATIVEX = pos.x - assignedBoxGlobal().x; const float BARRELATIVEX = pos.x - assignedBoxGlobal().x;
const float BARRELATIVEY = pos.y - assignedBoxGlobal().y; const float BARRELATIVEY = pos.y - assignedBoxGlobal().y;
const int WINDOWINDEX = *PSTACKED ? (BARRELATIVEY / (m_fBarHeight + *POUTERGAP)) : (BARRELATIVEX) / (m_fBarWidth + *PINNERGAP); const int WINDOWINDEX = *PSTACKED ? (BARRELATIVEY / (m_barHeight + *POUTERGAP)) : (BARRELATIVEX) / (m_barWidth + *PINNERGAP);
static auto PFOLLOWMOUSE = CConfigValue<Hyprlang::INT>("input:follow_mouse"); static auto PFOLLOWMOUSE = CConfigValue<Hyprlang::INT>("input:follow_mouse");
// close window on middle click // close window on middle click
@ -508,7 +508,7 @@ bool CHyprGroupBarDecoration::onMouseButtonOnDeco(const Vector2D& pos, const IPo
if (e.state == WL_POINTER_BUTTON_STATE_PRESSED) if (e.state == WL_POINTER_BUTTON_STATE_PRESSED)
pressedCursorPos = pos; pressedCursorPos = pos;
else if (e.state == WL_POINTER_BUTTON_STATE_RELEASED && pressedCursorPos == pos) else if (e.state == WL_POINTER_BUTTON_STATE_RELEASED && pressedCursorPos == pos)
g_pXWaylandManager->sendCloseWindow(m_pWindow->getGroupWindowByIndex(WINDOWINDEX)); g_pXWaylandManager->sendCloseWindow(m_window->getGroupWindowByIndex(WINDOWINDEX));
return true; return true;
} }
@ -517,17 +517,17 @@ bool CHyprGroupBarDecoration::onMouseButtonOnDeco(const Vector2D& pos, const IPo
return true; return true;
// click on padding // click on padding
const auto TABPAD = !*PSTACKED && (BARRELATIVEX - (m_fBarWidth + *PINNERGAP) * WINDOWINDEX > m_fBarWidth); const auto TABPAD = !*PSTACKED && (BARRELATIVEX - (m_barWidth + *PINNERGAP) * WINDOWINDEX > m_barWidth);
const auto STACKPAD = *PSTACKED && (BARRELATIVEY - (m_fBarHeight + *POUTERGAP) * WINDOWINDEX < *POUTERGAP); const auto STACKPAD = *PSTACKED && (BARRELATIVEY - (m_barHeight + *POUTERGAP) * WINDOWINDEX < *POUTERGAP);
if (TABPAD || STACKPAD) { if (TABPAD || STACKPAD) {
if (!g_pCompositor->isWindowActive(m_pWindow.lock())) if (!g_pCompositor->isWindowActive(m_window.lock()))
g_pCompositor->focusWindow(m_pWindow.lock()); g_pCompositor->focusWindow(m_window.lock());
return true; return true;
} }
PHLWINDOW pWindow = m_pWindow->getGroupWindowByIndex(WINDOWINDEX); PHLWINDOW pWindow = m_window->getGroupWindowByIndex(WINDOWINDEX);
if (pWindow != m_pWindow) if (pWindow != m_window)
pWindow->setGroupCurrent(pWindow); pWindow->setGroupCurrent(pWindow);
if (!g_pCompositor->isWindowActive(pWindow) && *PFOLLOWMOUSE != 3) if (!g_pCompositor->isWindowActive(pWindow) && *PFOLLOWMOUSE != 3)
@ -542,13 +542,13 @@ bool CHyprGroupBarDecoration::onMouseButtonOnDeco(const Vector2D& pos, const IPo
bool CHyprGroupBarDecoration::onScrollOnDeco(const Vector2D& pos, const IPointer::SAxisEvent e) { bool CHyprGroupBarDecoration::onScrollOnDeco(const Vector2D& pos, const IPointer::SAxisEvent e) {
static auto PGROUPBARSCROLLING = CConfigValue<Hyprlang::INT>("group:groupbar:scrolling"); static auto PGROUPBARSCROLLING = CConfigValue<Hyprlang::INT>("group:groupbar:scrolling");
if (!*PGROUPBARSCROLLING || m_pWindow->m_groupData.pNextWindow.expired()) if (!*PGROUPBARSCROLLING || m_window->m_groupData.pNextWindow.expired())
return false; return false;
if (e.delta > 0) if (e.delta > 0)
m_pWindow->setGroupCurrent(m_pWindow->m_groupData.pNextWindow.lock()); m_window->setGroupCurrent(m_window->m_groupData.pNextWindow.lock());
else else
m_pWindow->setGroupCurrent(m_pWindow->getGroupPrevious()); m_window->setGroupCurrent(m_window->getGroupPrevious());
return true; return true;
} }
@ -576,12 +576,12 @@ std::string CHyprGroupBarDecoration::getDisplayName() {
} }
CBox CHyprGroupBarDecoration::assignedBoxGlobal() { CBox CHyprGroupBarDecoration::assignedBoxGlobal() {
CBox box = m_bAssignedBox; CBox box = m_assignedBox;
box.translate(g_pDecorationPositioner->getEdgeDefinedPoint(DECORATION_EDGE_TOP, m_pWindow.lock())); box.translate(g_pDecorationPositioner->getEdgeDefinedPoint(DECORATION_EDGE_TOP, m_window.lock()));
const auto PWORKSPACE = m_pWindow->m_workspace; const auto PWORKSPACE = m_window->m_workspace;
if (PWORKSPACE && !m_pWindow->m_pinned) if (PWORKSPACE && !m_window->m_pinned)
box.translate(PWORKSPACE->m_renderOffset->value()); box.translate(PWORKSPACE->m_renderOffset->value());
return box.round(); return box.round();

20
src/render/decorations/CHyprGroupBarDecoration.hpp
View File

@ -12,11 +12,11 @@ class CTitleTex {
CTitleTex(PHLWINDOW pWindow, const Vector2D& bufferSize, const float monitorScale); CTitleTex(PHLWINDOW pWindow, const Vector2D& bufferSize, const float monitorScale);
~CTitleTex() = default; ~CTitleTex() = default;
SP<CTexture> texActive; SP<CTexture> m_texActive;
SP<CTexture> texInactive; SP<CTexture> m_texInactive;
std::string szContent; std::string m_content;
PHLWINDOWREF pWindowOwner; PHLWINDOWREF m_windowOwner;
}; };
void refreshGroupBarGradients(); void refreshGroupBarGradients();
@ -47,16 +47,14 @@ class CHyprGroupBarDecoration : public IHyprWindowDecoration {
virtual std::string getDisplayName(); virtual std::string getDisplayName();
private: private:
SBoxExtents m_seExtents; CBox m_assignedBox = {0};
CBox m_bAssignedBox = {0}; PHLWINDOWREF m_window;
PHLWINDOWREF m_pWindow;
std::vector<PHLWINDOWREF> m_dwGroupMembers; std::vector<PHLWINDOWREF> m_dwGroupMembers;
float m_fBarWidth; float m_barWidth;
float m_fBarHeight; float m_barHeight;
CTitleTex* textureFromTitle(const std::string&); CTitleTex* textureFromTitle(const std::string&);
void invalidateTextures(); void invalidateTextures();
@ -71,5 +69,5 @@ class CHyprGroupBarDecoration : public IHyprWindowDecoration {
struct STitleTexs { struct STitleTexs {
// STitleTexs* overriden = nullptr; // TODO: make shit shared in-group to decrease VRAM usage. // STitleTexs* overriden = nullptr; // TODO: make shit shared in-group to decrease VRAM usage.
std::vector<UP<CTitleTex>> titleTexs; std::vector<UP<CTitleTex>> titleTexs;
} m_sTitleTexs; } m_titleTexs;
}; };

42
src/render/decorations/DecorationPositioner.cpp
View File

@ -59,10 +59,10 @@ Vector2D CDecorationPositioner::getEdgeDefinedPoint(uint32_t edges, PHLWINDOW pW
} }
void CDecorationPositioner::uncacheDecoration(IHyprWindowDecoration* deco) { void CDecorationPositioner::uncacheDecoration(IHyprWindowDecoration* deco) {
std::erase_if(m_vWindowPositioningDatas, [&](const auto& data) { return !data->pWindow.lock() || data->pDecoration == deco; }); std::erase_if(m_windowPositioningDatas, [&](const auto& data) { return !data->pWindow.lock() || data->pDecoration == deco; });
const auto WIT = std::find_if(m_mWindowDatas.begin(), m_mWindowDatas.end(), [&](const auto& other) { return other.first.lock() == deco->m_pWindow.lock(); }); const auto WIT = std::find_if(m_windowDatas.begin(), m_windowDatas.end(), [&](const auto& other) { return other.first.lock() == deco->m_window.lock(); });
if (WIT == m_mWindowDatas.end()) if (WIT == m_windowDatas.end())
return; return;
WIT->second.needsRecalc = true; WIT->second.needsRecalc = true;
@ -70,16 +70,16 @@ void CDecorationPositioner::uncacheDecoration(IHyprWindowDecoration* deco) {
void CDecorationPositioner::repositionDeco(IHyprWindowDecoration* deco) { void CDecorationPositioner::repositionDeco(IHyprWindowDecoration* deco) {
uncacheDecoration(deco); uncacheDecoration(deco);
onWindowUpdate(deco->m_pWindow.lock()); onWindowUpdate(deco->m_window.lock());
} }
CDecorationPositioner::SWindowPositioningData* CDecorationPositioner::getDataFor(IHyprWindowDecoration* pDecoration, PHLWINDOW pWindow) { CDecorationPositioner::SWindowPositioningData* CDecorationPositioner::getDataFor(IHyprWindowDecoration* pDecoration, PHLWINDOW pWindow) {
auto it = std::find_if(m_vWindowPositioningDatas.begin(), m_vWindowPositioningDatas.end(), [&](const auto& el) { return el->pDecoration == pDecoration; }); auto it = std::find_if(m_windowPositioningDatas.begin(), m_windowPositioningDatas.end(), [&](const auto& el) { return el->pDecoration == pDecoration; });
if (it != m_vWindowPositioningDatas.end()) if (it != m_windowPositioningDatas.end())
return it->get(); return it->get();
const auto DATA = m_vWindowPositioningDatas.emplace_back(makeUnique<CDecorationPositioner::SWindowPositioningData>(pWindow, pDecoration)).get(); const auto DATA = m_windowPositioningDatas.emplace_back(makeUnique<CDecorationPositioner::SWindowPositioningData>(pWindow, pDecoration)).get();
DATA->positioningInfo = pDecoration->getPositioningInfo(); DATA->positioningInfo = pDecoration->getPositioningInfo();
@ -87,8 +87,8 @@ CDecorationPositioner::SWindowPositioningData* CDecorationPositioner::getDataFor
} }
void CDecorationPositioner::sanitizeDatas() { void CDecorationPositioner::sanitizeDatas() {
std::erase_if(m_mWindowDatas, [](const auto& other) { return !valid(other.first); }); std::erase_if(m_windowDatas, [](const auto& other) { return !valid(other.first); });
std::erase_if(m_vWindowPositioningDatas, [](const auto& other) { std::erase_if(m_windowPositioningDatas, [](const auto& other) {
if (!validMapped(other->pWindow)) if (!validMapped(other->pWindow))
return true; return true;
if (std::find_if(other->pWindow->m_windowDecorations.begin(), other->pWindow->m_windowDecorations.end(), [&](const auto& el) { return el.get() == other->pDecoration; }) == if (std::find_if(other->pWindow->m_windowDecorations.begin(), other->pWindow->m_windowDecorations.end(), [&](const auto& el) { return el.get() == other->pDecoration; }) ==
@ -99,8 +99,8 @@ void CDecorationPositioner::sanitizeDatas() {
} }
void CDecorationPositioner::forceRecalcFor(PHLWINDOW pWindow) { void CDecorationPositioner::forceRecalcFor(PHLWINDOW pWindow) {
const auto WIT = std::find_if(m_mWindowDatas.begin(), m_mWindowDatas.end(), [&](const auto& other) { return other.first.lock() == pWindow; }); const auto WIT = std::find_if(m_windowDatas.begin(), m_windowDatas.end(), [&](const auto& other) { return other.first.lock() == pWindow; });
if (WIT == m_mWindowDatas.end()) if (WIT == m_windowDatas.end())
return; return;
const auto WINDOWDATA = &WIT->second; const auto WINDOWDATA = &WIT->second;
@ -112,8 +112,8 @@ void CDecorationPositioner::onWindowUpdate(PHLWINDOW pWindow) {
if (!validMapped(pWindow)) if (!validMapped(pWindow))
return; return;
const auto WIT = std::find_if(m_mWindowDatas.begin(), m_mWindowDatas.end(), [&](const auto& other) { return other.first.lock() == pWindow; }); const auto WIT = std::find_if(m_windowDatas.begin(), m_windowDatas.end(), [&](const auto& other) { return other.first.lock() == pWindow; });
if (WIT == m_mWindowDatas.end()) if (WIT == m_windowDatas.end())
return; return;
const auto WINDOWDATA = &WIT->second; const auto WINDOWDATA = &WIT->second;
@ -130,7 +130,7 @@ void CDecorationPositioner::onWindowUpdate(PHLWINDOW pWindow) {
} }
if (WINDOWDATA->lastWindowSize == pWindow->m_realSize->value() /* position not changed */ if (WINDOWDATA->lastWindowSize == pWindow->m_realSize->value() /* position not changed */
&& std::all_of(m_vWindowPositioningDatas.begin(), m_vWindowPositioningDatas.end(), && std::all_of(m_windowPositioningDatas.begin(), m_windowPositioningDatas.end(),
[pWindow](const auto& data) { return pWindow != data->pWindow.lock() || !data->needsReposition; }) [pWindow](const auto& data) { return pWindow != data->pWindow.lock() || !data->needsReposition; })
/* all window datas are either not for this window or don't need a reposition */ /* all window datas are either not for this window or don't need a reposition */
&& !WINDOWDATA->needsRecalc /* window doesn't need recalc */ && !WINDOWDATA->needsRecalc /* window doesn't need recalc */
@ -282,17 +282,17 @@ void CDecorationPositioner::onWindowUpdate(PHLWINDOW pWindow) {
} }
void CDecorationPositioner::onWindowUnmap(PHLWINDOW pWindow) { void CDecorationPositioner::onWindowUnmap(PHLWINDOW pWindow) {
std::erase_if(m_vWindowPositioningDatas, [&](const auto& data) { return data->pWindow.lock() == pWindow; }); std::erase_if(m_windowPositioningDatas, [&](const auto& data) { return data->pWindow.lock() == pWindow; });
m_mWindowDatas.erase(pWindow); m_windowDatas.erase(pWindow);
} }
void CDecorationPositioner::onWindowMap(PHLWINDOW pWindow) { void CDecorationPositioner::onWindowMap(PHLWINDOW pWindow) {
m_mWindowDatas[pWindow] = {}; m_windowDatas[pWindow] = {};
} }
SBoxExtents CDecorationPositioner::getWindowDecorationReserved(PHLWINDOW pWindow) { SBoxExtents CDecorationPositioner::getWindowDecorationReserved(PHLWINDOW pWindow) {
try { try {
const auto E = m_mWindowDatas.at(pWindow); const auto E = m_windowDatas.at(pWindow);
return E.reserved; return E.reserved;
} catch (std::out_of_range& e) { return {}; } } catch (std::out_of_range& e) { return {}; }
} }
@ -301,7 +301,7 @@ SBoxExtents CDecorationPositioner::getWindowDecorationExtents(PHLWINDOW pWindow,
CBox const mainSurfaceBox = pWindow->getWindowMainSurfaceBox(); CBox const mainSurfaceBox = pWindow->getWindowMainSurfaceBox();
CBox accum = mainSurfaceBox; CBox accum = mainSurfaceBox;
for (auto const& data : m_vWindowPositioningDatas) { for (auto const& data : m_windowPositioningDatas) {
if (!data->pDecoration || (inputOnly && !(data->pDecoration->getDecorationFlags() & DECORATION_ALLOWS_MOUSE_INPUT))) if (!data->pDecoration || (inputOnly && !(data->pDecoration->getDecorationFlags() & DECORATION_ALLOWS_MOUSE_INPUT)))
continue; continue;
@ -349,7 +349,7 @@ SBoxExtents CDecorationPositioner::getWindowDecorationExtents(PHLWINDOW pWindow,
CBox CDecorationPositioner::getBoxWithIncludedDecos(PHLWINDOW pWindow) { CBox CDecorationPositioner::getBoxWithIncludedDecos(PHLWINDOW pWindow) {
CBox accum = pWindow->getWindowMainSurfaceBox(); CBox accum = pWindow->getWindowMainSurfaceBox();
for (auto const& data : m_vWindowPositioningDatas) { for (auto const& data : m_windowPositioningDatas) {
if (data->pWindow.lock() != pWindow) if (data->pWindow.lock() != pWindow)
continue; continue;
@ -385,7 +385,7 @@ CBox CDecorationPositioner::getBoxWithIncludedDecos(PHLWINDOW pWindow) {
} }
CBox CDecorationPositioner::getWindowDecorationBox(IHyprWindowDecoration* deco) { CBox CDecorationPositioner::getWindowDecorationBox(IHyprWindowDecoration* deco) {
auto const window = deco->m_pWindow.lock(); auto const window = deco->m_window.lock();
const auto DATA = getDataFor(deco, window); const auto DATA = getDataFor(deco, window);
CBox box = DATA->lastReply.assignedGeometry; CBox box = DATA->lastReply.assignedGeometry;

4
src/render/decorations/DecorationPositioner.hpp
View File

@ -87,8 +87,8 @@ class CDecorationPositioner {
bool needsRecalc = false; bool needsRecalc = false;
}; };
std::map<PHLWINDOWREF, SWindowData> m_mWindowDatas; std::map<PHLWINDOWREF, SWindowData> m_windowDatas;
std::vector<UP<SWindowPositioningData>> m_vWindowPositioningDatas; std::vector<UP<SWindowPositioningData>> m_windowPositioningDatas;
SWindowPositioningData* getDataFor(IHyprWindowDecoration* pDecoration, PHLWINDOW pWindow); SWindowPositioningData* getDataFor(IHyprWindowDecoration* pDecoration, PHLWINDOW pWindow);
void onWindowUnmap(PHLWINDOW pWindow); void onWindowUnmap(PHLWINDOW pWindow);

2
src/render/decorations/IHyprWindowDecoration.cpp
View File

@ -2,7 +2,7 @@
class CWindow; class CWindow;
IHyprWindowDecoration::IHyprWindowDecoration(PHLWINDOW pWindow) : m_pWindow(pWindow) { IHyprWindowDecoration::IHyprWindowDecoration(PHLWINDOW pWindow) : m_window(pWindow) {
; ;
} }

2
src/render/decorations/IHyprWindowDecoration.hpp
View File

@ -56,7 +56,7 @@ class IHyprWindowDecoration {
virtual std::string getDisplayName(); virtual std::string getDisplayName();
private: private:
PHLWINDOWREF m_pWindow; PHLWINDOWREF m_window;
friend class CDecorationPositioner; friend class CDecorationPositioner;
}; };

8
src/render/pass/BorderPassElement.cpp
View File

@ -1,15 +1,15 @@
#include "BorderPassElement.hpp" #include "BorderPassElement.hpp"
#include "../OpenGL.hpp" #include "../OpenGL.hpp"
CBorderPassElement::CBorderPassElement(const CBorderPassElement::SBorderData& data_) : data(data_) { CBorderPassElement::CBorderPassElement(const CBorderPassElement::SBorderData& data_) : m_data(data_) {
; ;
} }
void CBorderPassElement::draw(const CRegion& damage) { void CBorderPassElement::draw(const CRegion& damage) {
if (data.hasGrad2) if (m_data.hasGrad2)
g_pHyprOpenGL->renderBorder(data.box, data.grad1, data.grad2, data.lerp, data.round, data.roundingPower, data.borderSize, data.a, data.outerRound); g_pHyprOpenGL->renderBorder(m_data.box, m_data.grad1, m_data.grad2, m_data.lerp, m_data.round, m_data.roundingPower, m_data.borderSize, m_data.a, m_data.outerRound);
else else
g_pHyprOpenGL->renderBorder(data.box, data.grad1, data.round, data.roundingPower, data.borderSize, data.a, data.outerRound); g_pHyprOpenGL->renderBorder(m_data.box, m_data.grad1, m_data.round, m_data.roundingPower, m_data.borderSize, m_data.a, m_data.outerRound);
} }
bool CBorderPassElement::needsLiveBlur() { bool CBorderPassElement::needsLiveBlur() {

2
src/render/pass/BorderPassElement.hpp
View File

@ -27,5 +27,5 @@ class CBorderPassElement : public IPassElement {
} }
private: private:
SBorderData data; SBorderData m_data;
}; };

4
src/render/pass/ClearPassElement.cpp
View File

@ -1,12 +1,12 @@
#include "ClearPassElement.hpp" #include "ClearPassElement.hpp"
#include "../OpenGL.hpp" #include "../OpenGL.hpp"
CClearPassElement::CClearPassElement(const CClearPassElement::SClearData& data_) : data(data_) { CClearPassElement::CClearPassElement(const CClearPassElement::SClearData& data_) : m_data(data_) {
; ;
} }
void CClearPassElement::draw(const CRegion& damage) { void CClearPassElement::draw(const CRegion& damage) {
g_pHyprOpenGL->clear(data.color); g_pHyprOpenGL->clear(m_data.color);
} }
bool CClearPassElement::needsLiveBlur() { bool CClearPassElement::needsLiveBlur() {

2
src/render/pass/ClearPassElement.hpp
View File

@ -21,5 +21,5 @@ class CClearPassElement : public IPassElement {
} }
private: private:
SClearData data; SClearData m_data;
}; };

26
src/render/pass/FramebufferElement.cpp
View File

@ -1,18 +1,18 @@
#include "FramebufferElement.hpp" #include "FramebufferElement.hpp"
#include "../OpenGL.hpp" #include "../OpenGL.hpp"
CFramebufferElement::CFramebufferElement(const CFramebufferElement::SFramebufferElementData& data_) : data(data_) { CFramebufferElement::CFramebufferElement(const CFramebufferElement::SFramebufferElementData& data_) : m_data(data_) {
; ;
} }
void CFramebufferElement::draw(const CRegion& damage) { void CFramebufferElement::draw(const CRegion& damage) {
CFramebuffer* fb = nullptr; CFramebuffer* fb = nullptr;
if (data.main) { if (m_data.main) {
switch (data.framebufferID) { switch (m_data.framebufferID) {
case FB_MONITOR_RENDER_MAIN: fb = g_pHyprOpenGL->m_RenderData.mainFB; break; case FB_MONITOR_RENDER_MAIN: fb = g_pHyprOpenGL->m_renderData.mainFB; break;
case FB_MONITOR_RENDER_CURRENT: fb = g_pHyprOpenGL->m_RenderData.currentFB; break; case FB_MONITOR_RENDER_CURRENT: fb = g_pHyprOpenGL->m_renderData.currentFB; break;
case FB_MONITOR_RENDER_OUT: fb = g_pHyprOpenGL->m_RenderData.outFB; break; case FB_MONITOR_RENDER_OUT: fb = g_pHyprOpenGL->m_renderData.outFB; break;
} }
if (!fb) { if (!fb) {
@ -21,13 +21,13 @@ void CFramebufferElement::draw(const CRegion& damage) {
} }
} else { } else {
switch (data.framebufferID) { switch (m_data.framebufferID) {
case FB_MONITOR_RENDER_EXTRA_OFFLOAD: fb = &g_pHyprOpenGL->m_RenderData.pCurrentMonData->offloadFB; break; 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: 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_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_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_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_BLUR: fb = &g_pHyprOpenGL->m_renderData.pCurrentMonData->blurFB; break;
} }
if (!fb) { if (!fb) {

2
src/render/pass/FramebufferElement.hpp
View File

@ -21,5 +21,5 @@ class CFramebufferElement : public IPassElement {
} }
private: private:
SFramebufferElementData data; SFramebufferElementData m_data;
}; };

126
src/render/pass/Pass.cpp
View File

@ -15,11 +15,11 @@ bool CRenderPass::empty() const {
} }
bool CRenderPass::single() const { bool CRenderPass::single() const {
return m_vPassElements.size() == 1; return m_passElements.size() == 1;
} }
void CRenderPass::add(SP<IPassElement> el) { void CRenderPass::add(SP<IPassElement> el) {
m_vPassElements.emplace_back(makeShared<SPassElementData>(CRegion{}, el)); m_passElements.emplace_back(makeShared<SPassElementData>(CRegion{}, el));
} }
void CRenderPass::simplify() { void CRenderPass::simplify() {
@ -28,10 +28,10 @@ void CRenderPass::simplify() {
// TODO: use precompute blur for instances where there is nothing in between // TODO: use precompute blur for instances where there is nothing in between
// if there is live blur, we need to NOT occlude any area where it will be influenced // if there is live blur, we need to NOT occlude any area where it will be influenced
const auto WILLBLUR = std::ranges::any_of(m_vPassElements, [](const auto& el) { return el->element->needsLiveBlur(); }); const auto WILLBLUR = std::ranges::any_of(m_passElements, [](const auto& el) { return el->element->needsLiveBlur(); });
CRegion newDamage = damage.copy().intersect(CBox{{}, g_pHyprOpenGL->m_RenderData.pMonitor->m_transformedSize}); CRegion newDamage = m_damage.copy().intersect(CBox{{}, g_pHyprOpenGL->m_renderData.pMonitor->m_transformedSize});
for (auto& el : m_vPassElements | std::views::reverse) { for (auto& el : m_passElements | std::views::reverse) {
if (newDamage.empty() && !el->element->undiscardable()) { if (newDamage.empty() && !el->element->undiscardable()) {
el->discard = true; el->discard = true;
@ -43,7 +43,7 @@ void CRenderPass::simplify() {
if (!bb1 || newDamage.empty()) if (!bb1 || newDamage.empty())
continue; continue;
auto bb = bb1->scale(g_pHyprOpenGL->m_RenderData.pMonitor->m_scale); auto bb = bb1->scale(g_pHyprOpenGL->m_renderData.pMonitor->m_scale);
// drop if empty // drop if empty
if (CRegion copy = newDamage.copy(); copy.intersect(bb).empty()) { if (CRegion copy = newDamage.copy(); copy.intersect(bb).empty()) {
@ -54,13 +54,13 @@ void CRenderPass::simplify() {
auto opaque = el->element->opaqueRegion(); auto opaque = el->element->opaqueRegion();
if (!opaque.empty()) { if (!opaque.empty()) {
opaque.scale(g_pHyprOpenGL->m_RenderData.pMonitor->m_scale); opaque.scale(g_pHyprOpenGL->m_renderData.pMonitor->m_scale);
// if this intersects the liveBlur region, allow live blur to operate correctly. // if this intersects the liveBlur region, allow live blur to operate correctly.
// do not occlude a border near it. // do not occlude a border near it.
if (WILLBLUR) { if (WILLBLUR) {
CRegion liveBlurRegion; CRegion liveBlurRegion;
for (auto& el2 : m_vPassElements) { for (auto& el2 : m_passElements) {
// if we reach self, no problem, we can break. // if we reach self, no problem, we can break.
// if the blur is above us, we don't care, it will work fine. // if the blur is above us, we don't care, it will work fine.
if (el2 == el) if (el2 == el)
@ -76,7 +76,7 @@ void CRenderPass::simplify() {
} }
// expand the region: this area needs to be proper to blur it right. // expand the region: this area needs to be proper to blur it right.
liveBlurRegion.scale(g_pHyprOpenGL->m_RenderData.pMonitor->m_scale).expand(oneBlurRadius() * 2.F); liveBlurRegion.scale(g_pHyprOpenGL->m_renderData.pMonitor->m_scale).expand(oneBlurRadius() * 2.F);
if (auto infringement = opaque.copy().intersect(liveBlurRegion); !infringement.empty()) { if (auto infringement = opaque.copy().intersect(liveBlurRegion); !infringement.empty()) {
// eh, this is not the correct solution, but it will do... // eh, this is not the correct solution, but it will do...
@ -86,57 +86,57 @@ void CRenderPass::simplify() {
} }
newDamage.subtract(opaque); newDamage.subtract(opaque);
if (*PDEBUGPASS) if (*PDEBUGPASS)
occludedRegions.emplace_back(opaque); m_occludedRegions.emplace_back(opaque);
} }
} }
if (*PDEBUGPASS) { if (*PDEBUGPASS) {
for (auto& el2 : m_vPassElements) { for (auto& el2 : m_passElements) {
if (!el2->element->needsLiveBlur()) if (!el2->element->needsLiveBlur())
continue; continue;
const auto BB = el2->element->boundingBox(); const auto BB = el2->element->boundingBox();
RASSERT(BB, "No bounding box for an element with live blur is illegal"); RASSERT(BB, "No bounding box for an element with live blur is illegal");
totalLiveBlurRegion.add(BB->copy().scale(g_pHyprOpenGL->m_RenderData.pMonitor->m_scale)); m_totalLiveBlurRegion.add(BB->copy().scale(g_pHyprOpenGL->m_renderData.pMonitor->m_scale));
} }
} }
} }
void CRenderPass::clear() { void CRenderPass::clear() {
m_vPassElements.clear(); m_passElements.clear();
} }
CRegion CRenderPass::render(const CRegion& damage_) { CRegion CRenderPass::render(const CRegion& damage_) {
static auto PDEBUGPASS = CConfigValue<Hyprlang::INT>("debug:pass"); static auto PDEBUGPASS = CConfigValue<Hyprlang::INT>("debug:pass");
const auto WILLBLUR = std::ranges::any_of(m_vPassElements, [](const auto& el) { return el->element->needsLiveBlur(); }); const auto WILLBLUR = std::ranges::any_of(m_passElements, [](const auto& el) { return el->element->needsLiveBlur(); });
damage = *PDEBUGPASS ? CRegion{CBox{{}, {INT32_MAX, INT32_MAX}}} : damage_.copy(); m_damage = *PDEBUGPASS ? CRegion{CBox{{}, {INT32_MAX, INT32_MAX}}} : damage_.copy();
if (*PDEBUGPASS) { if (*PDEBUGPASS) {
occludedRegions.clear(); m_occludedRegions.clear();
totalLiveBlurRegion = CRegion{}; m_totalLiveBlurRegion = CRegion{};
} }
if (damage.empty()) { if (m_damage.empty()) {
g_pHyprOpenGL->m_RenderData.damage = damage; g_pHyprOpenGL->m_renderData.damage = m_damage;
g_pHyprOpenGL->m_RenderData.finalDamage = damage; g_pHyprOpenGL->m_renderData.finalDamage = m_damage;
return damage; return m_damage;
} }
if (!*PDEBUGPASS && debugData.present) if (!*PDEBUGPASS && m_debugData.present)
debugData = {false}; m_debugData = {false};
else if (*PDEBUGPASS && !debugData.present) { else if (*PDEBUGPASS && !m_debugData.present) {
debugData.present = true; m_debugData.present = true;
debugData.keyboardFocusText = g_pHyprOpenGL->renderText("keyboard", Colors::WHITE, 12); m_debugData.keyboardFocusText = g_pHyprOpenGL->renderText("keyboard", Colors::WHITE, 12);
debugData.pointerFocusText = g_pHyprOpenGL->renderText("pointer", Colors::WHITE, 12); m_debugData.pointerFocusText = g_pHyprOpenGL->renderText("pointer", Colors::WHITE, 12);
debugData.lastWindowText = g_pHyprOpenGL->renderText("lastWindow", Colors::WHITE, 12); m_debugData.lastWindowText = g_pHyprOpenGL->renderText("lastWindow", Colors::WHITE, 12);
} }
if (WILLBLUR && !*PDEBUGPASS) { if (WILLBLUR && !*PDEBUGPASS) {
// combine blur regions into one that will be expanded // combine blur regions into one that will be expanded
CRegion blurRegion; CRegion blurRegion;
for (auto& el : m_vPassElements) { for (auto& el : m_passElements) {
if (!el->element->needsLiveBlur()) if (!el->element->needsLiveBlur())
continue; continue;
@ -146,40 +146,40 @@ CRegion CRenderPass::render(const CRegion& damage_) {
blurRegion.add(*BB); blurRegion.add(*BB);
} }
blurRegion.scale(g_pHyprOpenGL->m_RenderData.pMonitor->m_scale); blurRegion.scale(g_pHyprOpenGL->m_renderData.pMonitor->m_scale);
blurRegion.intersect(damage).expand(oneBlurRadius()); blurRegion.intersect(m_damage).expand(oneBlurRadius());
g_pHyprOpenGL->m_RenderData.finalDamage = blurRegion.copy().add(damage); g_pHyprOpenGL->m_renderData.finalDamage = blurRegion.copy().add(m_damage);
// FIXME: why does this break on * 1.F ? // FIXME: why does this break on * 1.F ?
// used to work when we expand all the damage... I think? Well, before pass. // used to work when we expand all the damage... I think? Well, before pass.
// moving a window over blur shows the edges being wonk. // moving a window over blur shows the edges being wonk.
blurRegion.expand(oneBlurRadius() * 1.5F); blurRegion.expand(oneBlurRadius() * 1.5F);
damage = blurRegion.copy().add(damage); m_damage = blurRegion.copy().add(m_damage);
} else } else
g_pHyprOpenGL->m_RenderData.finalDamage = damage; g_pHyprOpenGL->m_renderData.finalDamage = m_damage;
if (std::ranges::any_of(m_vPassElements, [](const auto& el) { return el->element->disableSimplification(); })) { if (std::ranges::any_of(m_passElements, [](const auto& el) { return el->element->disableSimplification(); })) {
for (auto& el : m_vPassElements) { for (auto& el : m_passElements) {
el->elementDamage = damage; el->elementDamage = m_damage;
} }
} else } else
simplify(); simplify();
g_pHyprOpenGL->m_RenderData.pCurrentMonData->blurFBShouldRender = std::ranges::any_of(m_vPassElements, [](const auto& el) { return el->element->needsPrecomputeBlur(); }); g_pHyprOpenGL->m_renderData.pCurrentMonData->blurFBShouldRender = std::ranges::any_of(m_passElements, [](const auto& el) { return el->element->needsPrecomputeBlur(); });
if (m_vPassElements.empty()) if (m_passElements.empty())
return {}; return {};
for (auto& el : m_vPassElements) { for (auto& el : m_passElements) {
if (el->discard) { if (el->discard) {
el->element->discard(); el->element->discard();
continue; continue;
} }
g_pHyprOpenGL->m_RenderData.damage = el->elementDamage; g_pHyprOpenGL->m_renderData.damage = el->elementDamage;
el->element->draw(el->elementDamage); el->element->draw(el->elementDamage);
} }
@ -192,16 +192,16 @@ CRegion CRenderPass::render(const CRegion& damage_) {
}); });
} }
g_pHyprOpenGL->m_RenderData.damage = damage; g_pHyprOpenGL->m_renderData.damage = m_damage;
return damage; return m_damage;
} }
void CRenderPass::renderDebugData() { void CRenderPass::renderDebugData() {
CBox box = {{}, g_pHyprOpenGL->m_RenderData.pMonitor->m_transformedSize}; CBox box = {{}, g_pHyprOpenGL->m_renderData.pMonitor->m_transformedSize};
for (const auto& rg : occludedRegions) { for (const auto& rg : m_occludedRegions) {
g_pHyprOpenGL->renderRectWithDamage(box, Colors::RED.modifyA(0.1F), rg); g_pHyprOpenGL->renderRectWithDamage(box, Colors::RED.modifyA(0.1F), rg);
} }
g_pHyprOpenGL->renderRectWithDamage(box, Colors::GREEN.modifyA(0.1F), totalLiveBlurRegion); g_pHyprOpenGL->renderRectWithDamage(box, Colors::GREEN.modifyA(0.1F), m_totalLiveBlurRegion);
std::unordered_map<CWLSurfaceResource*, float> offsets; std::unordered_map<CWLSurfaceResource*, float> offsets;
@ -219,9 +219,9 @@ void CRenderPass::renderDebugData() {
if (!bb.has_value()) if (!bb.has_value())
return; return;
CBox box = bb->copy().translate(-g_pHyprOpenGL->m_RenderData.pMonitor->m_position).scale(g_pHyprOpenGL->m_RenderData.pMonitor->m_scale); CBox box = bb->copy().translate(-g_pHyprOpenGL->m_renderData.pMonitor->m_position).scale(g_pHyprOpenGL->m_renderData.pMonitor->m_scale);
if (box.intersection(CBox{{}, g_pHyprOpenGL->m_RenderData.pMonitor->m_size}).empty()) if (box.intersection(CBox{{}, g_pHyprOpenGL->m_renderData.pMonitor->m_size}).empty())
return; return;
g_pHyprOpenGL->renderRectWithDamage(box, color, CRegion{0, 0, INT32_MAX, INT32_MAX}); g_pHyprOpenGL->renderRectWithDamage(box, color, CRegion{0, 0, INT32_MAX, INT32_MAX});
@ -231,17 +231,17 @@ void CRenderPass::renderDebugData() {
else else
offsets[surface.get()] = 0; offsets[surface.get()] = 0;
box = {box.pos(), texture->m_vSize}; box = {box.pos(), texture->m_size};
g_pHyprOpenGL->renderRectWithDamage(box, CHyprColor{0.F, 0.F, 0.F, 0.2F}, CRegion{0, 0, INT32_MAX, INT32_MAX}, std::min(5.0, box.size().y)); g_pHyprOpenGL->renderRectWithDamage(box, CHyprColor{0.F, 0.F, 0.F, 0.2F}, CRegion{0, 0, INT32_MAX, INT32_MAX}, std::min(5.0, box.size().y));
g_pHyprOpenGL->renderTexture(texture, box, 1.F); g_pHyprOpenGL->renderTexture(texture, box, 1.F);
offsets[surface.get()] += texture->m_vSize.y; offsets[surface.get()] += texture->m_size.y;
}; };
renderHLSurface(debugData.keyboardFocusText, g_pSeatManager->m_state.keyboardFocus.lock(), Colors::PURPLE.modifyA(0.1F)); renderHLSurface(m_debugData.keyboardFocusText, g_pSeatManager->m_state.keyboardFocus.lock(), Colors::PURPLE.modifyA(0.1F));
renderHLSurface(debugData.pointerFocusText, g_pSeatManager->m_state.pointerFocus.lock(), Colors::ORANGE.modifyA(0.1F)); renderHLSurface(m_debugData.pointerFocusText, g_pSeatManager->m_state.pointerFocus.lock(), Colors::ORANGE.modifyA(0.1F));
if (g_pCompositor->m_lastWindow) if (g_pCompositor->m_lastWindow)
renderHLSurface(debugData.lastWindowText, g_pCompositor->m_lastWindow->m_wlSurface->resource(), Colors::LIGHT_BLUE.modifyA(0.1F)); renderHLSurface(m_debugData.lastWindowText, g_pCompositor->m_lastWindow->m_wlSurface->resource(), Colors::LIGHT_BLUE.modifyA(0.1F));
if (g_pSeatManager->m_state.pointerFocus) { if (g_pSeatManager->m_state.pointerFocus) {
if (g_pSeatManager->m_state.pointerFocus->m_current.input.intersect(CBox{{}, g_pSeatManager->m_state.pointerFocus->m_current.size}).getExtents().size() != if (g_pSeatManager->m_state.pointerFocus->m_current.input.intersect(CBox{{}, g_pSeatManager->m_state.pointerFocus->m_current.size}).getExtents().size() !=
@ -251,28 +251,28 @@ void CRenderPass::renderDebugData() {
auto BOX = hlSurface->getSurfaceBoxGlobal(); auto BOX = hlSurface->getSurfaceBoxGlobal();
if (BOX) { if (BOX) {
auto region = g_pSeatManager->m_state.pointerFocus->m_current.input.copy() auto region = g_pSeatManager->m_state.pointerFocus->m_current.input.copy()
.scale(g_pHyprOpenGL->m_RenderData.pMonitor->m_scale) .scale(g_pHyprOpenGL->m_renderData.pMonitor->m_scale)
.translate(BOX->pos() - g_pHyprOpenGL->m_RenderData.pMonitor->m_position); .translate(BOX->pos() - g_pHyprOpenGL->m_renderData.pMonitor->m_position);
g_pHyprOpenGL->renderRectWithDamage(box, CHyprColor{0.8F, 0.8F, 0.2F, 0.4F}, region); g_pHyprOpenGL->renderRectWithDamage(box, CHyprColor{0.8F, 0.8F, 0.2F, 0.4F}, region);
} }
} }
} }
} }
const auto DISCARDED_ELEMENTS = std::count_if(m_vPassElements.begin(), m_vPassElements.end(), [](const auto& e) { return e->discard; }); const auto DISCARDED_ELEMENTS = std::count_if(m_passElements.begin(), m_passElements.end(), [](const auto& e) { return e->discard; });
auto tex = g_pHyprOpenGL->renderText(std::format("occlusion layers: {}\npass elements: {} ({} discarded)\nviewport: {:X0}", occludedRegions.size(), m_vPassElements.size(), 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), DISCARDED_ELEMENTS, g_pHyprOpenGL->m_renderData.pMonitor->m_pixelSize),
Colors::WHITE, 12); Colors::WHITE, 12);
if (tex) { if (tex) {
box = CBox{{0.F, g_pHyprOpenGL->m_RenderData.pMonitor->m_size.y - tex->m_vSize.y}, tex->m_vSize}.scale(g_pHyprOpenGL->m_RenderData.pMonitor->m_scale); 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);
g_pHyprOpenGL->renderTexture(tex, box, 1.F); g_pHyprOpenGL->renderTexture(tex, box, 1.F);
} }
std::string passStructure; std::string passStructure;
auto yn = [](const bool val) -> const char* { return val ? "yes" : "no"; }; auto yn = [](const bool val) -> const char* { return val ? "yes" : "no"; };
auto tick = [](const bool val) -> const char* { return val ? "✔" : "✖"; }; auto tick = [](const bool val) -> const char* { return val ? "✔" : "✖"; };
for (const auto& el : m_vPassElements | std::views::reverse) { for (const auto& el : m_passElements | std::views::reverse) {
passStructure += std::format("{} {} (bb: {} op: {})\n", tick(!el->discard), el->element->passName(), yn(el->element->boundingBox().has_value()), passStructure += std::format("{} {} (bb: {} op: {})\n", tick(!el->discard), el->element->passName(), yn(el->element->boundingBox().has_value()),
yn(!el->element->opaqueRegion().empty())); yn(!el->element->opaqueRegion().empty()));
} }
@ -282,8 +282,8 @@ void CRenderPass::renderDebugData() {
tex = g_pHyprOpenGL->renderText(passStructure, Colors::WHITE, 12); tex = g_pHyprOpenGL->renderText(passStructure, Colors::WHITE, 12);
if (tex) { if (tex) {
box = CBox{{g_pHyprOpenGL->m_RenderData.pMonitor->m_size.x - tex->m_vSize.x, g_pHyprOpenGL->m_RenderData.pMonitor->m_size.y - tex->m_vSize.y}, tex->m_vSize}.scale( 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); g_pHyprOpenGL->m_renderData.pMonitor->m_scale);
g_pHyprOpenGL->renderTexture(tex, box, 1.F); g_pHyprOpenGL->renderTexture(tex, box, 1.F);
} }
} }
@ -296,5 +296,5 @@ float CRenderPass::oneBlurRadius() {
} }
void CRenderPass::removeAllOfType(const std::string& type) { void CRenderPass::removeAllOfType(const std::string& type) {
std::erase_if(m_vPassElements, [&type](const auto& e) { return e->element->passName() == type; }); std::erase_if(m_passElements, [&type](const auto& e) { return e->element->passName() == type; });
} }

12
src/render/pass/Pass.hpp
View File

@ -18,9 +18,9 @@ class CRenderPass {
CRegion render(const CRegion& damage_); CRegion render(const CRegion& damage_);
private: private:
CRegion damage; CRegion m_damage;
std::vector<CRegion> occludedRegions; std::vector<CRegion> m_occludedRegions;
CRegion totalLiveBlurRegion; CRegion m_totalLiveBlurRegion;
struct SPassElementData { struct SPassElementData {
CRegion elementDamage; CRegion elementDamage;
@ -28,9 +28,7 @@ class CRenderPass {
bool discard = false; bool discard = false;
}; };
std::vector<SP<SPassElementData>> m_vPassElements; std::vector<SP<SPassElementData>> m_passElements;
SP<IPassElement> currentPassInfo = nullptr;
void simplify(); void simplify();
float oneBlurRadius(); float oneBlurRadius();
@ -39,7 +37,7 @@ class CRenderPass {
struct { struct {
bool present = false; bool present = false;
SP<CTexture> keyboardFocusText, pointerFocusText, lastWindowText; SP<CTexture> keyboardFocusText, pointerFocusText, lastWindowText;
} debugData; } m_debugData;
friend class CHyprOpenGLImpl; friend class CHyprOpenGLImpl;
}; };

30
src/render/pass/RectPassElement.cpp
View File

@ -1,45 +1,45 @@
#include "RectPassElement.hpp" #include "RectPassElement.hpp"
#include "../OpenGL.hpp" #include "../OpenGL.hpp"
CRectPassElement::CRectPassElement(const CRectPassElement::SRectData& data_) : data(data_) { CRectPassElement::CRectPassElement(const CRectPassElement::SRectData& data_) : m_data(data_) {
; ;
} }
void CRectPassElement::draw(const CRegion& damage) { void CRectPassElement::draw(const CRegion& damage) {
if (data.box.w <= 0 || data.box.h <= 0) if (m_data.box.w <= 0 || m_data.box.h <= 0)
return; return;
if (!data.clipBox.empty()) if (!m_data.clipBox.empty())
g_pHyprOpenGL->m_RenderData.clipBox = data.clipBox; g_pHyprOpenGL->m_renderData.clipBox = m_data.clipBox;
if (data.color.a == 1.F || !data.blur) if (m_data.color.a == 1.F || !m_data.blur)
g_pHyprOpenGL->renderRectWithDamage(data.box, data.color, damage, data.round, data.roundingPower); g_pHyprOpenGL->renderRectWithDamage(m_data.box, m_data.color, damage, m_data.round, m_data.roundingPower);
else else
g_pHyprOpenGL->renderRectWithBlur(data.box, data.color, data.round, data.roundingPower, data.blurA, data.xray); g_pHyprOpenGL->renderRectWithBlur(m_data.box, m_data.color, m_data.round, m_data.roundingPower, m_data.blurA, m_data.xray);
g_pHyprOpenGL->m_RenderData.clipBox = {}; g_pHyprOpenGL->m_renderData.clipBox = {};
} }
bool CRectPassElement::needsLiveBlur() { bool CRectPassElement::needsLiveBlur() {
return data.color.a < 1.F && !data.xray && data.blur; return m_data.color.a < 1.F && !m_data.xray && m_data.blur;
} }
bool CRectPassElement::needsPrecomputeBlur() { bool CRectPassElement::needsPrecomputeBlur() {
return data.color.a < 1.F && data.xray && data.blur; return m_data.color.a < 1.F && m_data.xray && m_data.blur;
} }
std::optional<CBox> CRectPassElement::boundingBox() { std::optional<CBox> CRectPassElement::boundingBox() {
return data.box.copy().scale(1.F / g_pHyprOpenGL->m_RenderData.pMonitor->m_scale).round(); return m_data.box.copy().scale(1.F / g_pHyprOpenGL->m_renderData.pMonitor->m_scale).round();
} }
CRegion CRectPassElement::opaqueRegion() { CRegion CRectPassElement::opaqueRegion() {
if (data.color.a < 1.F) if (m_data.color.a < 1.F)
return CRegion{}; return CRegion{};
CRegion rg = boundingBox()->expand(-data.round); CRegion rg = boundingBox()->expand(-m_data.round);
if (!data.clipBox.empty()) if (!m_data.clipBox.empty())
rg.intersect(data.clipBox); rg.intersect(m_data.clipBox);
return rg; return rg;
} }

2
src/render/pass/RectPassElement.hpp
View File

@ -27,5 +27,5 @@ class CRectPassElement : public IPassElement {
} }
private: private:
SRectData data; SRectData m_data;
}; };

6
src/render/pass/RendererHintsPassElement.cpp
View File

@ -1,13 +1,13 @@
#include "RendererHintsPassElement.hpp" #include "RendererHintsPassElement.hpp"
#include "../OpenGL.hpp" #include "../OpenGL.hpp"
CRendererHintsPassElement::CRendererHintsPassElement(const CRendererHintsPassElement::SData& data_) : data(data_) { CRendererHintsPassElement::CRendererHintsPassElement(const CRendererHintsPassElement::SData& data_) : m_data(data_) {
; ;
} }
void CRendererHintsPassElement::draw(const CRegion& damage) { void CRendererHintsPassElement::draw(const CRegion& damage) {
if (data.renderModif.has_value()) if (m_data.renderModif.has_value())
g_pHyprOpenGL->m_RenderData.renderModif = *data.renderModif; g_pHyprOpenGL->m_renderData.renderModif = *m_data.renderModif;
} }
bool CRendererHintsPassElement::needsLiveBlur() { bool CRendererHintsPassElement::needsLiveBlur() {

2
src/render/pass/RendererHintsPassElement.hpp
View File

@ -22,5 +22,5 @@ class CRendererHintsPassElement : public IPassElement {
} }
private: private:
SData data; SData m_data;
}; };

4
src/render/pass/ShadowPassElement.cpp
View File

@ -2,12 +2,12 @@
#include "../OpenGL.hpp" #include "../OpenGL.hpp"
#include "../decorations/CHyprDropShadowDecoration.hpp" #include "../decorations/CHyprDropShadowDecoration.hpp"
CShadowPassElement::CShadowPassElement(const CShadowPassElement::SShadowData& data_) : data(data_) { CShadowPassElement::CShadowPassElement(const CShadowPassElement::SShadowData& data_) : m_data(data_) {
; ;
} }
void CShadowPassElement::draw(const CRegion& damage) { void CShadowPassElement::draw(const CRegion& damage) {
data.deco->render(g_pHyprOpenGL->m_RenderData.pMonitor.lock(), data.a); m_data.deco->render(g_pHyprOpenGL->m_renderData.pMonitor.lock(), m_data.a);
} }
bool CShadowPassElement::needsLiveBlur() { bool CShadowPassElement::needsLiveBlur() {

2
src/render/pass/ShadowPassElement.hpp
View File

@ -22,5 +22,5 @@ class CShadowPassElement : public IPassElement {
} }
private: private:
SShadowData data; SShadowData m_data;
}; };

174
src/render/pass/SurfacePassElement.cpp
View File

@ -12,59 +12,59 @@
#include <hyprutils/utils/ScopeGuard.hpp> #include <hyprutils/utils/ScopeGuard.hpp>
using namespace Hyprutils::Utils; using namespace Hyprutils::Utils;
CSurfacePassElement::CSurfacePassElement(const CSurfacePassElement::SRenderData& data_) : data(data_) { CSurfacePassElement::CSurfacePassElement(const CSurfacePassElement::SRenderData& data_) : m_data(data_) {
; ;
} }
void CSurfacePassElement::draw(const CRegion& damage) { void CSurfacePassElement::draw(const CRegion& damage) {
g_pHyprOpenGL->m_RenderData.currentWindow = data.pWindow; g_pHyprOpenGL->m_renderData.currentWindow = m_data.pWindow;
g_pHyprOpenGL->m_RenderData.surface = data.surface; g_pHyprOpenGL->m_renderData.surface = m_data.surface;
g_pHyprOpenGL->m_RenderData.currentLS = data.pLS; g_pHyprOpenGL->m_renderData.currentLS = m_data.pLS;
g_pHyprOpenGL->m_RenderData.clipBox = data.clipBox; g_pHyprOpenGL->m_renderData.clipBox = m_data.clipBox;
g_pHyprOpenGL->m_RenderData.discardMode = data.discardMode; g_pHyprOpenGL->m_renderData.discardMode = m_data.discardMode;
g_pHyprOpenGL->m_RenderData.discardOpacity = data.discardOpacity; g_pHyprOpenGL->m_renderData.discardOpacity = m_data.discardOpacity;
g_pHyprOpenGL->m_RenderData.useNearestNeighbor = data.useNearestNeighbor; g_pHyprOpenGL->m_renderData.useNearestNeighbor = m_data.useNearestNeighbor;
g_pHyprOpenGL->m_bEndFrame = data.flipEndFrame; g_pHyprOpenGL->m_endFrame = m_data.flipEndFrame;
CScopeGuard x = {[]() { CScopeGuard x = {[]() {
g_pHyprOpenGL->m_RenderData.primarySurfaceUVTopLeft = Vector2D(-1, -1); g_pHyprOpenGL->m_renderData.primarySurfaceUVTopLeft = Vector2D(-1, -1);
g_pHyprOpenGL->m_RenderData.primarySurfaceUVBottomRight = Vector2D(-1, -1); g_pHyprOpenGL->m_renderData.primarySurfaceUVBottomRight = Vector2D(-1, -1);
g_pHyprOpenGL->m_RenderData.useNearestNeighbor = false; g_pHyprOpenGL->m_renderData.useNearestNeighbor = false;
g_pHyprOpenGL->m_RenderData.clipBox = {}; g_pHyprOpenGL->m_renderData.clipBox = {};
g_pHyprOpenGL->m_RenderData.clipRegion = {}; g_pHyprOpenGL->m_renderData.clipRegion = {};
g_pHyprOpenGL->m_RenderData.discardMode = 0; g_pHyprOpenGL->m_renderData.discardMode = 0;
g_pHyprOpenGL->m_RenderData.discardOpacity = 0; g_pHyprOpenGL->m_renderData.discardOpacity = 0;
g_pHyprOpenGL->m_RenderData.useNearestNeighbor = false; g_pHyprOpenGL->m_renderData.useNearestNeighbor = false;
g_pHyprOpenGL->m_bEndFrame = false; g_pHyprOpenGL->m_endFrame = false;
g_pHyprOpenGL->m_RenderData.currentWindow.reset(); g_pHyprOpenGL->m_renderData.currentWindow.reset();
g_pHyprOpenGL->m_RenderData.surface.reset(); g_pHyprOpenGL->m_renderData.surface.reset();
g_pHyprOpenGL->m_RenderData.currentLS.reset(); g_pHyprOpenGL->m_renderData.currentLS.reset();
}}; }};
if (!data.texture) if (!m_data.texture)
return; return;
const auto& TEXTURE = data.texture; const auto& TEXTURE = m_data.texture;
// this is bad, probably has been logged elsewhere. Means the texture failed // this is bad, probably has been logged elsewhere. Means the texture failed
// uploading to the GPU. // uploading to the GPU.
if (!TEXTURE->m_iTexID) if (!TEXTURE->m_texID)
return; return;
const auto INTERACTIVERESIZEINPROGRESS = data.pWindow && g_pInputManager->m_currentlyDraggedWindow && g_pInputManager->m_dragMode == MBIND_RESIZE; const auto INTERACTIVERESIZEINPROGRESS = m_data.pWindow && g_pInputManager->m_currentlyDraggedWindow && g_pInputManager->m_dragMode == MBIND_RESIZE;
TRACY_GPU_ZONE("RenderSurface"); TRACY_GPU_ZONE("RenderSurface");
auto PSURFACE = CWLSurface::fromResource(data.surface); auto PSURFACE = CWLSurface::fromResource(m_data.surface);
const float ALPHA = data.alpha * data.fadeAlpha * (PSURFACE ? PSURFACE->m_alphaModifier : 1.F); const float ALPHA = m_data.alpha * m_data.fadeAlpha * (PSURFACE ? PSURFACE->m_alphaModifier : 1.F);
const float OVERALL_ALPHA = PSURFACE ? PSURFACE->m_overallOpacity : 1.F; const float OVERALL_ALPHA = PSURFACE ? PSURFACE->m_overallOpacity : 1.F;
const bool BLUR = data.blur && (!TEXTURE->m_bOpaque || ALPHA < 1.F || OVERALL_ALPHA < 1.F); const bool BLUR = m_data.blur && (!TEXTURE->m_opaque || ALPHA < 1.F || OVERALL_ALPHA < 1.F);
auto windowBox = getTexBox(); auto windowBox = getTexBox();
const auto PROJSIZEUNSCALED = windowBox.size(); const auto PROJSIZEUNSCALED = windowBox.size();
windowBox.scale(data.pMonitor->m_scale); windowBox.scale(m_data.pMonitor->m_scale);
windowBox.round(); windowBox.round();
if (windowBox.width <= 1 || windowBox.height <= 1) { if (windowBox.width <= 1 || windowBox.height <= 1) {
@ -72,17 +72,17 @@ void CSurfacePassElement::draw(const CRegion& damage) {
return; return;
} }
const bool MISALIGNEDFSV1 = std::floor(data.pMonitor->m_scale) != data.pMonitor->m_scale /* Fractional */ && data.surface->m_current.scale == 1 /* fs protocol */ && const bool MISALIGNEDFSV1 = std::floor(m_data.pMonitor->m_scale) != m_data.pMonitor->m_scale /* Fractional */ && m_data.surface->m_current.scale == 1 /* fs protocol */ &&
windowBox.size() != data.surface->m_current.bufferSize /* misaligned */ && DELTALESSTHAN(windowBox.width, data.surface->m_current.bufferSize.x, 3) && windowBox.size() != m_data.surface->m_current.bufferSize /* misaligned */ && DELTALESSTHAN(windowBox.width, m_data.surface->m_current.bufferSize.x, 3) &&
DELTALESSTHAN(windowBox.height, data.surface->m_current.bufferSize.y, 3) /* off by one-or-two */ && DELTALESSTHAN(windowBox.height, m_data.surface->m_current.bufferSize.y, 3) /* off by one-or-two */ &&
(!data.pWindow || (!data.pWindow->m_realSize->isBeingAnimated() && !INTERACTIVERESIZEINPROGRESS)) /* not window or not animated/resizing */; (!m_data.pWindow || (!m_data.pWindow->m_realSize->isBeingAnimated() && !INTERACTIVERESIZEINPROGRESS)) /* not window or not animated/resizing */;
if (data.surface->m_colorManagement.valid()) if (m_data.surface->m_colorManagement.valid())
Debug::log(TRACE, "FIXME: rendering surface with color management enabled, should apply necessary transformations"); Debug::log(TRACE, "FIXME: rendering surface with color management enabled, should apply necessary transformations");
g_pHyprRenderer->calculateUVForSurface(data.pWindow, data.surface, data.pMonitor->m_self.lock(), data.mainSurface, windowBox.size(), PROJSIZEUNSCALED, MISALIGNEDFSV1); g_pHyprRenderer->calculateUVForSurface(m_data.pWindow, m_data.surface, m_data.pMonitor->m_self.lock(), m_data.mainSurface, windowBox.size(), PROJSIZEUNSCALED, MISALIGNEDFSV1);
auto cancelRender = false; auto cancelRender = false;
g_pHyprOpenGL->m_RenderData.clipRegion = visibleRegion(cancelRender); g_pHyprOpenGL->m_renderData.clipRegion = visibleRegion(cancelRender);
if (cancelRender) if (cancelRender)
return; return;
@ -91,19 +91,19 @@ void CSurfacePassElement::draw(const CRegion& damage) {
// as long as the window is not animated. During those it'd look weird. // as long as the window is not animated. During those it'd look weird.
// UV will fixup it as well // UV will fixup it as well
if (MISALIGNEDFSV1) if (MISALIGNEDFSV1)
g_pHyprOpenGL->m_RenderData.useNearestNeighbor = true; g_pHyprOpenGL->m_renderData.useNearestNeighbor = true;
float rounding = data.rounding; float rounding = m_data.rounding;
float roundingPower = data.roundingPower; float roundingPower = m_data.roundingPower;
rounding -= 1; // to fix a border issue rounding -= 1; // to fix a border issue
if (data.dontRound) { if (m_data.dontRound) {
rounding = 0; rounding = 0;
roundingPower = 2.0f; roundingPower = 2.0f;
} }
const bool WINDOWOPAQUE = data.pWindow && data.pWindow->m_wlSurface->resource() == data.surface ? data.pWindow->opaque() : false; const bool WINDOWOPAQUE = m_data.pWindow && m_data.pWindow->m_wlSurface->resource() == m_data.surface ? m_data.pWindow->opaque() : false;
const bool CANDISABLEBLEND = ALPHA >= 1.f && OVERALL_ALPHA >= 1.f && rounding == 0 && WINDOWOPAQUE; const bool CANDISABLEBLEND = ALPHA >= 1.f && OVERALL_ALPHA >= 1.f && rounding == 0 && WINDOWOPAQUE;
if (CANDISABLEBLEND) if (CANDISABLEBLEND)
@ -114,38 +114,38 @@ void CSurfacePassElement::draw(const CRegion& damage) {
// FIXME: This is wrong and will bug the blur out as shit if the first surface // FIXME: This is wrong and will bug the blur out as shit if the first surface
// is a subsurface that does NOT cover the entire frame. In such cases, we probably should fall back // is a subsurface that does NOT cover the entire frame. In such cases, we probably should fall back
// to what we do for misaligned surfaces (blur the entire thing and then render shit without blur) // to what we do for misaligned surfaces (blur the entire thing and then render shit without blur)
if (data.surfaceCounter == 0 && !data.popup) { if (m_data.surfaceCounter == 0 && !m_data.popup) {
if (BLUR) if (BLUR)
g_pHyprOpenGL->renderTextureWithBlur(TEXTURE, windowBox, ALPHA, data.surface, rounding, roundingPower, data.blockBlurOptimization, data.fadeAlpha, OVERALL_ALPHA); g_pHyprOpenGL->renderTextureWithBlur(TEXTURE, windowBox, ALPHA, m_data.surface, rounding, roundingPower, m_data.blockBlurOptimization, m_data.fadeAlpha, OVERALL_ALPHA);
else else
g_pHyprOpenGL->renderTexture(TEXTURE, windowBox, ALPHA * OVERALL_ALPHA, rounding, roundingPower, false, true); g_pHyprOpenGL->renderTexture(TEXTURE, windowBox, ALPHA * OVERALL_ALPHA, rounding, roundingPower, false, true);
} else { } else {
if (BLUR && data.popup) if (BLUR && m_data.popup)
g_pHyprOpenGL->renderTextureWithBlur(TEXTURE, windowBox, ALPHA, data.surface, rounding, roundingPower, true, data.fadeAlpha, OVERALL_ALPHA); g_pHyprOpenGL->renderTextureWithBlur(TEXTURE, windowBox, ALPHA, m_data.surface, rounding, roundingPower, true, m_data.fadeAlpha, OVERALL_ALPHA);
else else
g_pHyprOpenGL->renderTexture(TEXTURE, windowBox, ALPHA * OVERALL_ALPHA, rounding, roundingPower, false, true); g_pHyprOpenGL->renderTexture(TEXTURE, windowBox, ALPHA * OVERALL_ALPHA, rounding, roundingPower, false, true);
} }
if (!g_pHyprRenderer->m_bBlockSurfaceFeedback) if (!g_pHyprRenderer->m_bBlockSurfaceFeedback)
data.surface->presentFeedback(data.when, data.pMonitor->m_self.lock()); m_data.surface->presentFeedback(m_data.when, m_data.pMonitor->m_self.lock());
// add async (dmabuf) buffers to usedBuffers so we can handle release later // add async (dmabuf) buffers to usedBuffers so we can handle release later
// sync (shm) buffers will be released in commitState, so no need to track them here // sync (shm) buffers will be released in commitState, so no need to track them here
if (data.surface->m_current.buffer && !data.surface->m_current.buffer->isSynchronous()) if (m_data.surface->m_current.buffer && !m_data.surface->m_current.buffer->isSynchronous())
g_pHyprRenderer->usedAsyncBuffers.emplace_back(data.surface->m_current.buffer); g_pHyprRenderer->m_usedAsyncBuffers.emplace_back(m_data.surface->m_current.buffer);
g_pHyprOpenGL->blend(true); g_pHyprOpenGL->blend(true);
} }
CBox CSurfacePassElement::getTexBox() { CBox CSurfacePassElement::getTexBox() {
const double outputX = -data.pMonitor->m_position.x, outputY = -data.pMonitor->m_position.y; const double outputX = -m_data.pMonitor->m_position.x, outputY = -m_data.pMonitor->m_position.y;
const auto INTERACTIVERESIZEINPROGRESS = data.pWindow && g_pInputManager->m_currentlyDraggedWindow && g_pInputManager->m_dragMode == MBIND_RESIZE; const auto INTERACTIVERESIZEINPROGRESS = m_data.pWindow && g_pInputManager->m_currentlyDraggedWindow && g_pInputManager->m_dragMode == MBIND_RESIZE;
auto PSURFACE = CWLSurface::fromResource(data.surface); auto PSURFACE = CWLSurface::fromResource(m_data.surface);
CBox windowBox; CBox windowBox;
if (data.surface && data.mainSurface) { if (m_data.surface && m_data.mainSurface) {
windowBox = {(int)outputX + data.pos.x + data.localPos.x, (int)outputY + data.pos.y + data.localPos.y, data.w, data.h}; windowBox = {(int)outputX + m_data.pos.x + m_data.localPos.x, (int)outputY + m_data.pos.y + m_data.localPos.y, m_data.w, m_data.h};
// however, if surface buffer w / h < box, we need to adjust them // however, if surface buffer w / h < box, we need to adjust them
const auto PWINDOW = PSURFACE ? PSURFACE->getWindow() : nullptr; const auto PWINDOW = PSURFACE ? PSURFACE->getWindow() : nullptr;
@ -167,49 +167,49 @@ CBox CSurfacePassElement::getTexBox() {
} }
} else { // here we clamp to 2, these might be some tiny specks } else { // here we clamp to 2, these might be some tiny specks
windowBox = {(int)outputX + data.pos.x + data.localPos.x, (int)outputY + data.pos.y + data.localPos.y, std::max((float)data.surface->m_current.size.x, 2.F), windowBox = {(int)outputX + m_data.pos.x + m_data.localPos.x, (int)outputY + m_data.pos.y + m_data.localPos.y, std::max((float)m_data.surface->m_current.size.x, 2.F),
std::max((float)data.surface->m_current.size.y, 2.F)}; std::max((float)m_data.surface->m_current.size.y, 2.F)};
if (data.pWindow && data.pWindow->m_realSize->isBeingAnimated() && data.surface && !data.mainSurface && data.squishOversized /* subsurface */) { if (m_data.pWindow && m_data.pWindow->m_realSize->isBeingAnimated() && m_data.surface && !m_data.mainSurface && m_data.squishOversized /* subsurface */) {
// adjust subsurfaces to the window // adjust subsurfaces to the window
windowBox.width = (windowBox.width / data.pWindow->m_reportedSize.x) * data.pWindow->m_realSize->value().x; windowBox.width = (windowBox.width / m_data.pWindow->m_reportedSize.x) * m_data.pWindow->m_realSize->value().x;
windowBox.height = (windowBox.height / data.pWindow->m_reportedSize.y) * data.pWindow->m_realSize->value().y; windowBox.height = (windowBox.height / m_data.pWindow->m_reportedSize.y) * m_data.pWindow->m_realSize->value().y;
} }
} }
if (data.squishOversized) { if (m_data.squishOversized) {
if (data.localPos.x + windowBox.width > data.w) if (m_data.localPos.x + windowBox.width > m_data.w)
windowBox.width = data.w - data.localPos.x; windowBox.width = m_data.w - m_data.localPos.x;
if (data.localPos.y + windowBox.height > data.h) if (m_data.localPos.y + windowBox.height > m_data.h)
windowBox.height = data.h - data.localPos.y; windowBox.height = m_data.h - m_data.localPos.y;
} }
return windowBox; return windowBox;
} }
bool CSurfacePassElement::needsLiveBlur() { bool CSurfacePassElement::needsLiveBlur() {
auto PSURFACE = CWLSurface::fromResource(data.surface); auto PSURFACE = CWLSurface::fromResource(m_data.surface);
const float ALPHA = data.alpha * data.fadeAlpha * (PSURFACE ? PSURFACE->m_alphaModifier * PSURFACE->m_overallOpacity : 1.F); const float ALPHA = m_data.alpha * m_data.fadeAlpha * (PSURFACE ? PSURFACE->m_alphaModifier * PSURFACE->m_overallOpacity : 1.F);
const bool BLUR = data.blur && (!data.texture || !data.texture->m_bOpaque || ALPHA < 1.F); const bool BLUR = m_data.blur && (!m_data.texture || !m_data.texture->m_opaque || ALPHA < 1.F);
if (!data.pLS && !data.pWindow) if (!m_data.pLS && !m_data.pWindow)
return BLUR; return BLUR;
const bool NEWOPTIM = g_pHyprOpenGL->shouldUseNewBlurOptimizations(data.pLS, data.pWindow); const bool NEWOPTIM = g_pHyprOpenGL->shouldUseNewBlurOptimizations(m_data.pLS, m_data.pWindow);
return BLUR && !NEWOPTIM; return BLUR && !NEWOPTIM;
} }
bool CSurfacePassElement::needsPrecomputeBlur() { bool CSurfacePassElement::needsPrecomputeBlur() {
auto PSURFACE = CWLSurface::fromResource(data.surface); auto PSURFACE = CWLSurface::fromResource(m_data.surface);
const float ALPHA = data.alpha * data.fadeAlpha * (PSURFACE ? PSURFACE->m_alphaModifier * PSURFACE->m_overallOpacity : 1.F); const float ALPHA = m_data.alpha * m_data.fadeAlpha * (PSURFACE ? PSURFACE->m_alphaModifier * PSURFACE->m_overallOpacity : 1.F);
const bool BLUR = data.blur && (!data.texture || !data.texture->m_bOpaque || ALPHA < 1.F); const bool BLUR = m_data.blur && (!m_data.texture || !m_data.texture->m_opaque || ALPHA < 1.F);
if (!data.pLS && !data.pWindow) if (!m_data.pLS && !m_data.pWindow)
return BLUR; return BLUR;
const bool NEWOPTIM = g_pHyprOpenGL->shouldUseNewBlurOptimizations(data.pLS, data.pWindow); const bool NEWOPTIM = g_pHyprOpenGL->shouldUseNewBlurOptimizations(m_data.pLS, m_data.pWindow);
return BLUR && NEWOPTIM; return BLUR && NEWOPTIM;
} }
@ -219,29 +219,29 @@ std::optional<CBox> CSurfacePassElement::boundingBox() {
} }
CRegion CSurfacePassElement::opaqueRegion() { CRegion CSurfacePassElement::opaqueRegion() {
auto PSURFACE = CWLSurface::fromResource(data.surface); auto PSURFACE = CWLSurface::fromResource(m_data.surface);
const float ALPHA = data.alpha * data.fadeAlpha * (PSURFACE ? PSURFACE->m_alphaModifier * PSURFACE->m_overallOpacity : 1.F); const float ALPHA = m_data.alpha * m_data.fadeAlpha * (PSURFACE ? PSURFACE->m_alphaModifier * PSURFACE->m_overallOpacity : 1.F);
if (ALPHA < 1.F) if (ALPHA < 1.F)
return {}; return {};
if (data.surface && data.surface->m_current.size == Vector2D{data.w, data.h}) { if (m_data.surface && m_data.surface->m_current.size == Vector2D{m_data.w, m_data.h}) {
CRegion opaqueSurf = data.surface->m_current.opaque.copy().intersect(CBox{{}, {data.w, data.h}}); CRegion opaqueSurf = m_data.surface->m_current.opaque.copy().intersect(CBox{{}, {m_data.w, m_data.h}});
const auto texBox = getTexBox(); const auto texBox = getTexBox();
opaqueSurf.scale(texBox.size() / Vector2D{data.w, data.h}); opaqueSurf.scale(texBox.size() / Vector2D{m_data.w, m_data.h});
return opaqueSurf.translate(data.pos + data.localPos - data.pMonitor->m_position).expand(-data.rounding); return opaqueSurf.translate(m_data.pos + m_data.localPos - m_data.pMonitor->m_position).expand(-m_data.rounding);
} }
return data.texture && data.texture->m_bOpaque ? boundingBox()->expand(-data.rounding) : CRegion{}; return m_data.texture && m_data.texture->m_opaque ? boundingBox()->expand(-m_data.rounding) : CRegion{};
} }
CRegion CSurfacePassElement::visibleRegion(bool& cancel) { CRegion CSurfacePassElement::visibleRegion(bool& cancel) {
auto PSURFACE = CWLSurface::fromResource(data.surface); auto PSURFACE = CWLSurface::fromResource(m_data.surface);
if (!PSURFACE) if (!PSURFACE)
return {}; return {};
const auto& bufferSize = data.surface->m_current.bufferSize; const auto& bufferSize = m_data.surface->m_current.bufferSize;
auto visibleRegion = PSURFACE->m_visibleRegion.copy(); auto visibleRegion = PSURFACE->m_visibleRegion.copy();
if (visibleRegion.empty()) if (visibleRegion.empty())
@ -257,8 +257,8 @@ CRegion CSurfacePassElement::visibleRegion(bool& cancel) {
// deal with any rounding errors that might come from scaling // deal with any rounding errors that might come from scaling
visibleRegion.expand(1); visibleRegion.expand(1);
auto uvTL = g_pHyprOpenGL->m_RenderData.primarySurfaceUVTopLeft; auto uvTL = g_pHyprOpenGL->m_renderData.primarySurfaceUVTopLeft;
auto uvBR = g_pHyprOpenGL->m_RenderData.primarySurfaceUVBottomRight; auto uvBR = g_pHyprOpenGL->m_renderData.primarySurfaceUVBottomRight;
if (uvTL == Vector2D(-1, -1)) if (uvTL == Vector2D(-1, -1))
uvTL = Vector2D(0, 0); uvTL = Vector2D(0, 0);
@ -269,11 +269,11 @@ CRegion CSurfacePassElement::visibleRegion(bool& cancel) {
visibleRegion.translate(-uvTL * bufferSize); visibleRegion.translate(-uvTL * bufferSize);
auto texBox = getTexBox(); auto texBox = getTexBox();
texBox.scale(data.pMonitor->m_scale); texBox.scale(m_data.pMonitor->m_scale);
texBox.round(); texBox.round();
visibleRegion.scale((Vector2D(1, 1) / (uvBR - uvTL)) * (texBox.size() / bufferSize)); visibleRegion.scale((Vector2D(1, 1) / (uvBR - uvTL)) * (texBox.size() / bufferSize));
visibleRegion.translate((data.pos + data.localPos) * data.pMonitor->m_scale - data.pMonitor->m_position); visibleRegion.translate((m_data.pos + m_data.localPos) * m_data.pMonitor->m_scale - m_data.pMonitor->m_position);
return visibleRegion; return visibleRegion;
} }
@ -281,6 +281,6 @@ CRegion CSurfacePassElement::visibleRegion(bool& cancel) {
void CSurfacePassElement::discard() { void CSurfacePassElement::discard() {
if (!g_pHyprRenderer->m_bBlockSurfaceFeedback) { if (!g_pHyprRenderer->m_bBlockSurfaceFeedback) {
Debug::log(TRACE, "discard for invisible surface"); Debug::log(TRACE, "discard for invisible surface");
data.surface->presentFeedback(data.when, data.pMonitor->m_self.lock(), true); m_data.surface->presentFeedback(m_data.when, m_data.pMonitor->m_self.lock(), true);
} }
} }

2
src/render/pass/SurfacePassElement.hpp
View File

@ -65,7 +65,7 @@ class CSurfacePassElement : public IPassElement {
} }
private: private:
SRenderData data; SRenderData m_data;
CBox getTexBox(); CBox getTexBox();
}; };

24
src/render/pass/TexPassElement.cpp
View File

@ -4,27 +4,27 @@
#include <hyprutils/utils/ScopeGuard.hpp> #include <hyprutils/utils/ScopeGuard.hpp>
using namespace Hyprutils::Utils; using namespace Hyprutils::Utils;
CTexPassElement::CTexPassElement(const CTexPassElement::SRenderData& data_) : data(data_) { CTexPassElement::CTexPassElement(const CTexPassElement::SRenderData& data_) : m_data(data_) {
; ;
} }
void CTexPassElement::draw(const CRegion& damage) { void CTexPassElement::draw(const CRegion& damage) {
g_pHyprOpenGL->m_bEndFrame = data.flipEndFrame; g_pHyprOpenGL->m_endFrame = m_data.flipEndFrame;
CScopeGuard x = {[]() { CScopeGuard x = {[]() {
// //
g_pHyprOpenGL->m_bEndFrame = false; g_pHyprOpenGL->m_endFrame = false;
g_pHyprOpenGL->m_RenderData.clipBox = {}; g_pHyprOpenGL->m_renderData.clipBox = {};
}}; }};
if (!data.clipBox.empty()) if (!m_data.clipBox.empty())
g_pHyprOpenGL->m_RenderData.clipBox = data.clipBox; g_pHyprOpenGL->m_renderData.clipBox = m_data.clipBox;
if (data.replaceProjection) if (m_data.replaceProjection)
g_pHyprOpenGL->m_RenderData.monitorProjection = *data.replaceProjection; g_pHyprOpenGL->m_renderData.monitorProjection = *m_data.replaceProjection;
g_pHyprOpenGL->renderTextureInternalWithDamage(data.tex, data.box, data.a, data.damage.empty() ? damage : data.damage, data.round, data.roundingPower); g_pHyprOpenGL->renderTextureInternalWithDamage(m_data.tex, m_data.box, m_data.a, m_data.damage.empty() ? damage : m_data.damage, m_data.round, m_data.roundingPower);
if (data.replaceProjection) if (m_data.replaceProjection)
g_pHyprOpenGL->m_RenderData.monitorProjection = g_pHyprOpenGL->m_RenderData.pMonitor->m_projMatrix; g_pHyprOpenGL->m_renderData.monitorProjection = g_pHyprOpenGL->m_renderData.pMonitor->m_projMatrix;
} }
bool CTexPassElement::needsLiveBlur() { bool CTexPassElement::needsLiveBlur() {
@ -36,7 +36,7 @@ bool CTexPassElement::needsPrecomputeBlur() {
} }
std::optional<CBox> CTexPassElement::boundingBox() { std::optional<CBox> CTexPassElement::boundingBox() {
return data.box.copy().scale(1.F / g_pHyprOpenGL->m_RenderData.pMonitor->m_scale).round(); return m_data.box.copy().scale(1.F / g_pHyprOpenGL->m_renderData.pMonitor->m_scale).round();
} }
CRegion CTexPassElement::opaqueRegion() { CRegion CTexPassElement::opaqueRegion() {

2
src/render/pass/TexPassElement.hpp
View File

@ -35,5 +35,5 @@ class CTexPassElement : public IPassElement {
} }
private: private:
SRenderData data; SRenderData m_data;
}; };

8
src/render/pass/TextureMatteElement.cpp
View File

@ -1,19 +1,19 @@
#include "TextureMatteElement.hpp" #include "TextureMatteElement.hpp"
#include "../OpenGL.hpp" #include "../OpenGL.hpp"
CTextureMatteElement::CTextureMatteElement(const CTextureMatteElement::STextureMatteData& data_) : data(data_) { CTextureMatteElement::CTextureMatteElement(const CTextureMatteElement::STextureMatteData& data_) : m_data(data_) {
; ;
} }
void CTextureMatteElement::draw(const CRegion& damage) { void CTextureMatteElement::draw(const CRegion& damage) {
if (data.disableTransformAndModify) { if (m_data.disableTransformAndModify) {
g_pHyprOpenGL->setMonitorTransformEnabled(true); g_pHyprOpenGL->setMonitorTransformEnabled(true);
g_pHyprOpenGL->setRenderModifEnabled(false); g_pHyprOpenGL->setRenderModifEnabled(false);
g_pHyprOpenGL->renderTextureMatte(data.tex, data.box, *data.fb); g_pHyprOpenGL->renderTextureMatte(m_data.tex, m_data.box, *m_data.fb);
g_pHyprOpenGL->setRenderModifEnabled(true); g_pHyprOpenGL->setRenderModifEnabled(true);
g_pHyprOpenGL->setMonitorTransformEnabled(false); g_pHyprOpenGL->setMonitorTransformEnabled(false);
} else } else
g_pHyprOpenGL->renderTextureMatte(data.tex, data.box, *data.fb); g_pHyprOpenGL->renderTextureMatte(m_data.tex, m_data.box, *m_data.fb);
} }
bool CTextureMatteElement::needsLiveBlur() { bool CTextureMatteElement::needsLiveBlur() {

2
src/render/pass/TextureMatteElement.hpp
View File

@ -25,5 +25,5 @@ class CTextureMatteElement : public IPassElement {
} }
private: private:
STextureMatteData data; STextureMatteData m_data;
}; };