hyprwm/Hyprland
1
0
Fork 0
mirror of https://github.com/hyprwm/Hyprland.git synced 2025-05-12 23:00:36 +01:00
Code Issues Projects Releases Packages Wiki Activity Actions 3

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() {
if (!getrlimit(RLIMIT_NOFILE, &m_sOriginalNofile))
Debug::log(LOG, "Old rlimit: soft -> {}, hard -> {}", m_sOriginalNofile.rlim_cur, m_sOriginalNofile.rlim_max);
if (!getrlimit(RLIMIT_NOFILE, &m_originalNofile))
Debug::log(LOG, "Old rlimit: soft -> {}, hard -> {}", m_originalNofile.rlim_cur, m_originalNofile.rlim_max);
else {
Debug::log(ERR, "Failed to get NOFILE rlimits");
m_sOriginalNofile.rlim_max = 0;
m_originalNofile.rlim_max = 0;
return;
}
rlimit newLimit = m_sOriginalNofile;
rlimit newLimit = m_originalNofile;
newLimit.rlim_cur = newLimit.rlim_max;
if (setrlimit(RLIMIT_NOFILE, &newLimit) < 0) {
Debug::log(ERR, "Failed bumping NOFILE limits higher");
m_sOriginalNofile.rlim_max = 0;
m_originalNofile.rlim_max = 0;
return;
}
@ -159,10 +159,10 @@ void CCompositor::bumpNofile() {
}
void CCompositor::restoreNofile() {
if (m_sOriginalNofile.rlim_max <= 0)
if (m_originalNofile.rlim_max <= 0)
return;
if (setrlimit(RLIMIT_NOFILE, &m_sOriginalNofile) < 0)
if (setrlimit(RLIMIT_NOFILE, &m_originalNofile) < 0)
Debug::log(ERR, "Failed restoring NOFILE limits");
}
@ -176,7 +176,7 @@ void CCompositor::setMallocThreshold() {
#endif
}
CCompositor::CCompositor(bool onlyConfig) : m_onlyConfigVerification(onlyConfig), m_iHyprlandPID(getpid()) {
CCompositor::CCompositor(bool onlyConfig) : m_onlyConfigVerification(onlyConfig), m_hyprlandPID(getpid()) {
if (onlyConfig)
return;
@ -225,7 +225,7 @@ CCompositor::CCompositor(bool onlyConfig) : m_onlyConfigVerification(onlyConfig)
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: =====");
@ -710,7 +710,7 @@ void CCompositor::createLockFile() {
std::ofstream ofs(PATH, std::ios::trunc);
ofs << m_iHyprlandPID << "\n" << m_wlDisplaySocket << "\n";
ofs << m_hyprlandPID << "\n" << m_wlDisplaySocket << "\n";
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_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);
}
}
@ -3033,8 +3033,8 @@ void CCompositor::onNewMonitor(SP<Aquamarine::IOutput> output) {
// 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)
g_pHyprRenderer->m_pMostHzMonitor = PNEWMONITOR;
if ((!g_pHyprRenderer->m_mostHzMonitor || PNEWMONITOR->m_refreshRate > g_pHyprRenderer->m_mostHzMonitor->m_refreshRate) && PNEWMONITOR->m_enabled)
g_pHyprRenderer->m_mostHzMonitor = PNEWMONITOR;
g_pCompositor->m_readyToProcess = true;

8
src/Compositor.hpp
View file

@ -152,7 +152,7 @@ class CCompositor {
NColorManagement::SImageDescription getPreferredImageDescription();
bool shouldChangePreferredImageDescription();
std::string explicitConfigPath;
std::string m_explicitConfigPath;
private:
void initAllSignals();
@ -165,9 +165,9 @@ class CCompositor {
void removeLockFile();
void setMallocThreshold();
uint64_t m_iHyprlandPID = 0;
wl_event_source* m_critSigSource = nullptr;
rlimit m_sOriginalNofile = {};
uint64_t m_hyprlandPID = 0;
wl_event_source* m_critSigSource = nullptr;
rlimit m_originalNofile = {};
};
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() {
static std::string CONFIG_PATH = [this]() -> std::string {
if (!g_pCompositor->explicitConfigPath.empty())
return g_pCompositor->explicitConfigPath;
if (!g_pCompositor->m_explicitConfigPath.empty())
return g_pCompositor->m_explicitConfigPath;
if (const auto CFG_ENV = getenv("HYPRLAND_CONFIG"); CFG_ENV)
return CFG_ENV;
@ -1025,7 +1025,7 @@ void CConfigManager::postConfigReload(const Hyprlang::CParseResult& result) {
g_pInputManager->setTouchDeviceConfigs();
g_pInputManager->setTabletConfigs();
g_pHyprOpenGL->m_bReloadScreenShader = true;
g_pHyprOpenGL->m_reloadScreenShader = true;
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
if (COMMAND.contains("decoration:screen_shader") || COMMAND == "source")
g_pHyprOpenGL->m_bReloadScreenShader = true;
g_pHyprOpenGL->m_reloadScreenShader = true;
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;
}
}
@ -1821,9 +1821,9 @@ std::string CHyprCtl::getReply(std::string request) {
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;
}

6
src/debug/HyprDebugOverlay.cpp
View file

@ -57,7 +57,7 @@ void CHyprMonitorDebugOverlay::frameData(PHLMONITOR pMonitor) {
m_monitor = pMonitor;
// 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 (m_lastAnimationTicks.size() > (long unsigned int)PMONITORFORTICKS->m_refreshRate)
m_lastAnimationTicks.pop_front();
@ -260,7 +260,7 @@ void CHyprDebugOverlay::draw() {
// copy the data to an OpenGL texture we have
const auto DATA = cairo_image_surface_get_data(m_cairoSurface);
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_MIN_FILTER, GL_NEAREST);
@ -274,5 +274,5 @@ void CHyprDebugOverlay::draw() {
CTexPassElement::SRenderData data;
data.tex = m_texture;
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
const auto DATA = cairo_image_surface_get_data(m_cairoSurface);
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_MIN_FILTER, GL_NEAREST);
@ -251,7 +251,7 @@ void CHyprNotificationOverlay::draw(PHLMONITOR pMonitor) {
data.box = {0, 0, MONSIZE.x, MONSIZE.y};
data.a = 1.F;
g_pHyprRenderer->m_sRenderPass.add(makeShared<CTexPassElement>(data));
g_pHyprRenderer->m_renderPass.add(makeShared<CTexPassElement>(data));
}
bool CHyprNotificationOverlay::hasAny() {

2
src/desktop/LayerSurface.cpp
View file

@ -74,7 +74,7 @@ CLayerSurface::~CLayerSurface() {
if (m_surface)
m_surface->unassign();
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& lsl : mon->m_layerSurfaceLayers) {

4
src/desktop/WLSurface.cpp
View file

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

6
src/desktop/Window.cpp
View file

@ -126,7 +126,7 @@ CWindow::~CWindow() {
return;
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() {
@ -1160,7 +1160,7 @@ bool CWindow::opaque() {
return false;
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)
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)
return true;
return m_wlSurface->resource()->m_current.texture->m_bOpaque;
return m_wlSurface->resource()->m_current.texture->m_opaque;
}
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)
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;
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; });
}
@ -1362,7 +1362,7 @@ void CMonitor::setCTM(const Mat3x3& ctm_) {
}
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.
if (g_pPointerManager->softwareLockedFor(m_self.lock()))
@ -1383,7 +1383,7 @@ bool CMonitor::attemptDirectScanout() {
// we can't scanout shm buffers.
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;
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
const auto DATA = cairo_image_surface_get_data(CAIROSURFACE);
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_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};
@ -211,7 +211,7 @@ void CHyprError::draw() {
data.box = monbox;
data.a = m_fadeOpacity->value();
g_pHyprRenderer->m_sRenderPass.add(makeShared<CTexPassElement>(data));
g_pHyprRenderer->m_renderPass.add(makeShared<CTexPassElement>(data));
}
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 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;
bool canSkipUpdate = true;

4
src/main.cpp
View file

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

2
src/managers/AnimationManager.cpp
View file

@ -255,7 +255,7 @@ void CHyprAnimationManager::scheduleTick() {
m_tickScheduled = true;
const auto PMOSTHZ = g_pHyprRenderer->m_pMostHzMonitor;
const auto PMOSTHZ = g_pHyprRenderer->m_mostHzMonitor;
if (!PMOSTHZ) {
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;
if (SURFACE->m_current.texture) {
Debug::log(TRACE, "Cursor CPU surface: format {}, expecting AR24", NFormatUtils::drmFormatName(SURFACE->m_current.texture->m_iDrmFormat));
if (SURFACE->m_current.texture->m_iDrmFormat == DRM_FORMAT_ABGR8888) {
Debug::log(TRACE, "Cursor CPU surface: format {}, expecting AR24", NFormatUtils::drmFormatName(SURFACE->m_current.texture->m_drmFormat));
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!");
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");
return nullptr;
}
@ -484,7 +484,7 @@ SP<Aquamarine::IBuffer> CPointerManager::renderHWCursorBuffer(SP<CPointerManager
if (shmBuffer.data())
texData = shmBuffer;
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());
}
@ -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 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);
cairo_set_operator(CAIRO, CAIRO_OPERATOR_SOURCE);
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);
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;
// 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);
if (TR) {
@ -564,7 +564,7 @@ SP<Aquamarine::IBuffer> CPointerManager::renderHWCursorBuffer(SP<CPointerManager
}
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);
if (!RBO) {
@ -585,7 +585,7 @@ SP<Aquamarine::IBuffer> CPointerManager::renderHWCursorBuffer(SP<CPointerManager
g_pHyprOpenGL->end();
glFlush();
g_pHyprOpenGL->m_RenderData.pMonitor.reset();
g_pHyprOpenGL->m_renderData.pMonitor.reset();
g_pHyprRenderer->onRenderbufferDestroy(RBO.get());
@ -625,7 +625,7 @@ void CPointerManager::renderSoftwareCursorsFor(PHLMONITOR pMonitor, const Time::
data.tex = texture;
data.box = box.round();
g_pHyprRenderer->m_sRenderPass.add(makeShared<CTexPassElement>(data));
g_pHyprRenderer->m_renderPass.add(makeShared<CTexPassElement>(data));
if (m_currentCursorImage.surface)
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);
g_pHyprRenderer->m_bDirectScanoutBlocked = true;
g_pHyprRenderer->m_directScanoutBlocked = true;
if (!m_withDamage)
g_pHyprRenderer->damageMonitor(m_monitor.lock());
@ -215,12 +215,11 @@ void CScreencopyFrame::copyDmabuf(std::function<void(bool)> callback) {
g_pHyprOpenGL->clear(Colors::BLACK);
else {
g_pHyprOpenGL->clear(Colors::BLACK);
CBox texbox =
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_pScreencopyDeniedTexture, texbox, 1);
CBox texbox = CBox{m_monitor->m_transformedSize / 2.F, g_pHyprOpenGL->m_screencopyDeniedTexture->m_size}.translate(-g_pHyprOpenGL->m_screencopyDeniedTexture->m_size / 2.F);
g_pHyprOpenGL->renderTexture(g_pHyprOpenGL->m_screencopyDeniedTexture, texbox, 1);
}
g_pHyprOpenGL->m_RenderData.blockScreenShader = true;
g_pHyprOpenGL->m_renderData.blockScreenShader = true;
g_pHyprRenderer->endRender([callback]() {
LOGM(TRACE, "Copied frame via dma");
@ -261,9 +260,8 @@ bool CScreencopyFrame::copyShm() {
g_pHyprOpenGL->clear(Colors::BLACK);
else {
g_pHyprOpenGL->clear(Colors::BLACK);
CBox texbox =
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_pScreencopyDeniedTexture, texbox, 1);
CBox texbox = CBox{m_monitor->m_transformedSize / 2.F, g_pHyprOpenGL->m_screencopyDeniedTexture->m_size}.translate(-g_pHyprOpenGL->m_screencopyDeniedTexture->m_size / 2.F);
g_pHyprOpenGL->renderTexture(g_pHyprOpenGL->m_screencopyDeniedTexture, texbox, 1);
}
#ifndef GLES2
@ -281,11 +279,11 @@ bool CScreencopyFrame::copyShm() {
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->makeEGLCurrent();
g_pHyprOpenGL->m_RenderData.pMonitor = m_monitor;
g_pHyprOpenGL->m_renderData.pMonitor = m_monitor;
fb.bind();
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
glBindFramebuffer(GL_READ_FRAMEBUFFER, 0);
@ -414,7 +412,7 @@ void CScreencopyProtocol::destroyResource(CScreencopyFrame* frame) {
void CScreencopyProtocol::onOutputCommit(PHLMONITOR pMonitor) {
if (m_framesAwaitingWrite.empty()) {
g_pHyprRenderer->m_bDirectScanoutBlocked = false;
g_pHyprRenderer->m_directScanoutBlocked = false;
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_success = m_texture->m_iTexID;
m_success = m_texture->m_texID;
size = {1, 1};

16
src/protocols/ToplevelExport.cpp
View file

@ -264,9 +264,8 @@ bool CToplevelExportFrame::copyShm(const Time::steady_tp& now) {
if (overlayCursor)
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) {
CBox texbox =
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_pScreencopyDeniedTexture, texbox, 1);
CBox texbox = CBox{PMONITOR->m_transformedSize / 2.F, g_pHyprOpenGL->m_screencopyDeniedTexture->m_size}.translate(-g_pHyprOpenGL->m_screencopyDeniedTexture->m_size / 2.F);
g_pHyprOpenGL->renderTexture(g_pHyprOpenGL->m_screencopyDeniedTexture, texbox, 1);
}
const auto PFORMAT = NFormatUtils::getPixelFormatFromDRM(shm.format);
@ -275,11 +274,11 @@ bool CToplevelExportFrame::copyShm(const Time::steady_tp& now) {
return false;
}
g_pHyprOpenGL->m_RenderData.blockScreenShader = true;
g_pHyprOpenGL->m_renderData.blockScreenShader = true;
g_pHyprRenderer->endRender();
g_pHyprRenderer->makeEGLCurrent();
g_pHyprOpenGL->m_RenderData.pMonitor = PMONITOR;
g_pHyprOpenGL->m_renderData.pMonitor = PMONITOR;
outFB.bind();
#ifndef GLES2
@ -352,12 +351,11 @@ bool CToplevelExportFrame::copyDmabuf(const Time::steady_tp& now) {
if (overlayCursor)
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) {
CBox texbox =
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_pScreencopyDeniedTexture, texbox, 1);
CBox texbox = CBox{PMONITOR->m_transformedSize / 2.F, g_pHyprOpenGL->m_screencopyDeniedTexture->m_size}.translate(-g_pHyprOpenGL->m_screencopyDeniedTexture->m_size / 2.F);
g_pHyprOpenGL->renderTexture(g_pHyprOpenGL->m_screencopyDeniedTexture, texbox, 1);
}
g_pHyprOpenGL->m_RenderData.blockScreenShader = true;
g_pHyprOpenGL->m_renderData.blockScreenShader = true;
g_pHyprRenderer->endRender();
if (overlayCursor) {

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

@ -495,7 +495,7 @@ void CWLSurfaceResource::commitState(SSurfaceState& state) {
}
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) {
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;
data.tex = m_dnd.dndSurface->m_current.texture;
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);
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_opaque = NFormatUtils::isFormatOpaque(m_attrs.format);
m_success = m_texture->m_iTexID;
m_success = m_texture->m_texID;
if UNLIKELY (!m_success)
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) {
auto drmFmt = NFormatUtils::shmToDRM(fmt);
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->update(drmFmt, dataPtr, stride, accumulateBufferDamage());
} 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 glType = NFormatUtils::glFormatToType(glFormat);
if (!m_cTex) {
m_cTex = makeShared<CTexture>();
m_cTex->allocate();
glBindTexture(GL_TEXTURE_2D, m_cTex->m_iTexID);
if (!m_tex) {
m_tex = makeShared<CTexture>();
m_tex->allocate();
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_T, GL_CLAMP_TO_EDGE);
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;
}
if (!m_iFbAllocated) {
glGenFramebuffers(1, &m_iFb);
m_iFbAllocated = true;
firstAlloc = true;
if (!m_fbAllocated) {
glGenFramebuffers(1, &m_fb);
m_fbAllocated = true;
firstAlloc = true;
}
if (firstAlloc || m_vSize != Vector2D(w, h)) {
glBindTexture(GL_TEXTURE_2D, m_cTex->m_iTexID);
if (firstAlloc || m_size != Vector2D(w, h)) {
glBindTexture(GL_TEXTURE_2D, m_tex->m_texID);
glTexImage2D(GL_TEXTURE_2D, 0, glFormat, w, h, 0, GL_RGBA, glType, nullptr);
glBindFramebuffer(GL_FRAMEBUFFER, m_iFb);
glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, m_cTex->m_iTexID, 0);
glBindFramebuffer(GL_FRAMEBUFFER, m_fb);
glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, m_tex->m_texID, 0);
// TODO: Allow this with gles2
#ifndef GLES2
if (m_pStencilTex) {
glBindTexture(GL_TEXTURE_2D, m_pStencilTex->m_iTexID);
if (m_stencilTex) {
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);
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
@ -53,7 +53,7 @@ bool CFramebuffer::alloc(int w, int h, uint32_t drmFormat) {
glBindTexture(GL_TEXTURE_2D, 0);
glBindFramebuffer(GL_FRAMEBUFFER, 0);
m_vSize = Vector2D(w, h);
m_size = Vector2D(w, h);
return true;
}
@ -61,13 +61,13 @@ bool CFramebuffer::alloc(int w, int h, uint32_t drmFormat) {
void CFramebuffer::addStencil(SP<CTexture> tex) {
// TODO: Allow this with gles2
#ifndef GLES2
m_pStencilTex = tex;
glBindTexture(GL_TEXTURE_2D, m_pStencilTex->m_iTexID);
glTexImage2D(GL_TEXTURE_2D, 0, GL_DEPTH24_STENCIL8, m_vSize.x, m_vSize.y, 0, GL_DEPTH_STENCIL, GL_UNSIGNED_INT_24_8, nullptr);
m_stencilTex = tex;
glBindTexture(GL_TEXTURE_2D, m_stencilTex->m_texID);
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);
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() {
#ifndef GLES2
glBindFramebuffer(GL_DRAW_FRAMEBUFFER, m_iFb);
glBindFramebuffer(GL_DRAW_FRAMEBUFFER, m_fb);
#else
glBindFramebuffer(GL_FRAMEBUFFER, m_iFb);
#endif
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
glViewport(0, 0, m_vSize.x, m_vSize.y);
glViewport(0, 0, m_size.x, m_size.y);
}
void CFramebuffer::unbind() {
@ -99,20 +99,20 @@ void CFramebuffer::unbind() {
}
void CFramebuffer::release() {
if (m_iFbAllocated) {
glBindFramebuffer(GL_FRAMEBUFFER, m_iFb);
if (m_fbAllocated) {
glBindFramebuffer(GL_FRAMEBUFFER, m_fb);
glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, 0, 0);
glBindFramebuffer(GL_FRAMEBUFFER, 0);
glDeleteFramebuffers(1, &m_iFb);
m_iFbAllocated = false;
m_iFb = 0;
glDeleteFramebuffers(1, &m_fb);
m_fbAllocated = false;
m_fb = 0;
}
if (m_cTex)
m_cTex.reset();
if (m_tex)
m_tex.reset();
m_vSize = Vector2D();
m_size = Vector2D();
}
CFramebuffer::~CFramebuffer() {
@ -120,17 +120,17 @@ CFramebuffer::~CFramebuffer() {
}
bool CFramebuffer::isAllocated() {
return m_iFbAllocated && m_cTex;
return m_fbAllocated && m_tex;
}
SP<CTexture> CFramebuffer::getTexture() {
return m_cTex;
return m_tex;
}
GLuint CFramebuffer::getFBID() {
return m_iFbAllocated ? m_iFb : 0;
return m_fbAllocated ? m_fb : 0;
}
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();
GLuint getFBID();
Vector2D m_vSize;
Vector2D m_size;
private:
SP<CTexture> m_cTex;
GLuint m_iFb = -1;
bool m_iFbAllocated = false;
SP<CTexture> m_tex;
GLuint m_fb = -1;
bool m_fbAllocated = false;
SP<CTexture> m_pStencilTex;
SP<CTexture> m_stencilTex;
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);
bool initShaders();
bool m_bShadersInitialized = false;
bool m_shadersInitialized = false;
SP<SPreparedShaders> m_shaders;
SCurrentRenderData m_RenderData;
SCurrentRenderData m_renderData;
Hyprutils::OS::CFileDescriptor m_iGBMFD;
gbm_device* m_pGbmDevice = nullptr;
EGLContext m_pEglContext = nullptr;
EGLDisplay m_pEglDisplay = nullptr;
EGLDeviceEXT m_pEglDevice = nullptr;
uint failedAssetsNo = 0;
Hyprutils::OS::CFileDescriptor m_gbmFD;
gbm_device* m_gbmDevice = nullptr;
EGLContext m_eglContext = nullptr;
EGLDisplay m_eglDisplay = nullptr;
EGLDeviceEXT m_eglDevice = nullptr;
uint m_failedAssetsNo = 0;
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<PHLLSREF, CFramebuffer> m_mLayerFramebuffers;
std::map<PHLMONITORREF, SMonitorRenderData> m_mMonitorRenderResources;
std::map<PHLMONITORREF, CFramebuffer> m_mMonitorBGFBs;
std::map<PHLWINDOWREF, CFramebuffer> m_windowFramebuffers;
std::map<PHLLSREF, CFramebuffer> m_layerFramebuffers;
std::map<PHLMONITORREF, SMonitorRenderData> m_monitorRenderResources;
std::map<PHLMONITORREF, CFramebuffer> m_monitorBGFBs;
struct {
PFNGLEGLIMAGETARGETRENDERBUFFERSTORAGEOESPROC glEGLImageTargetRenderbufferStorageOES = nullptr;
@ -274,7 +274,7 @@ class CHyprOpenGLImpl {
PFNEGLDESTROYSYNCKHRPROC eglDestroySyncKHR = nullptr;
PFNEGLDUPNATIVEFENCEFDANDROIDPROC eglDupNativeFenceFDANDROID = nullptr;
PFNEGLWAITSYNCKHRPROC eglWaitSyncKHR = nullptr;
} m_sProc;
} m_proc;
struct {
bool EXT_read_format_bgra = false;
@ -283,9 +283,9 @@ class CHyprOpenGLImpl {
bool KHR_display_reference = false;
bool IMG_context_priority = false;
bool EXT_create_context_robustness = false;
} m_sExts;
} m_exts;
SP<CTexture> m_pScreencopyDeniedTexture;
SP<CTexture> m_screencopyDeniedTexture;
private:
enum eEGLContextVersion : uint8_t {
@ -296,26 +296,27 @@ class CHyprOpenGLImpl {
eEGLContextVersion m_eglContextVersion = EGL_CONTEXT_GLES_3_2;
std::list<GLuint> m_lBuffers;
std::list<GLuint> m_lTextures;
std::vector<SDRMFormat> m_drmFormats;
bool m_hasModifiers = false;
std::vector<SDRMFormat> drmFormats;
bool m_bHasModifiers = false;
int m_drmFD = -1;
std::string m_extensions;
int m_iDRMFD = -1;
std::string m_szExtensions;
bool m_fakeFrame = false;
bool m_endFrame = false;
bool m_applyFinalShader = false;
bool m_blend = false;
bool m_offloadedFramebuffer = false;
bool m_cmSupported = true;
bool m_bFakeFrame = false;
bool m_bEndFrame = false;
bool m_bApplyFinalShader = false;
bool m_bBlend = false;
bool m_bOffloadedFramebuffer = false;
bool m_bCMSupported = true;
CShader m_finalScreenShader;
CTimer m_globalTimer;
CShader m_sFinalScreenShader;
CTimer m_tGlobalTimer;
SP<CTexture> m_pMissingAssetTexture, m_pBackgroundTexture, m_pLockDeadTexture, m_pLockDead2Texture, m_pLockTtyTextTexture; // TODO: don't always load lock
SP<CTexture> m_missingAssetTexture;
SP<CTexture> m_backgroundTexture;
SP<CTexture> m_lockDeadTexture;
SP<CTexture> m_lockDead2Texture;
SP<CTexture> m_lockTtyTextTexture; // TODO: don't always load lock
void logShaderError(const GLuint&, bool program = 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();
unbind();
m_sFramebuffer.release();
glDeleteRenderbuffers(1, &m_iRBO);
m_framebuffer.release();
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();
m_iImage = g_pHyprOpenGL->createEGLImage(dma);
if (m_iImage == EGL_NO_IMAGE_KHR) {
m_image = g_pHyprOpenGL->createEGLImage(dma);
if (m_image == EGL_NO_IMAGE_KHR) {
Debug::log(ERR, "rb: createEGLImage failed");
return;
}
glGenRenderbuffers(1, &m_iRBO);
glBindRenderbuffer(GL_RENDERBUFFER, m_iRBO);
g_pHyprOpenGL->m_sProc.glEGLImageTargetRenderbufferStorageOES(GL_RENDERBUFFER, (GLeglImageOES)m_iImage);
glGenRenderbuffers(1, &m_rbo);
glBindRenderbuffer(GL_RENDERBUFFER, m_rbo);
g_pHyprOpenGL->m_proc.glEGLImageTargetRenderbufferStorageOES(GL_RENDERBUFFER, (GLeglImageOES)m_image);
glBindRenderbuffer(GL_RENDERBUFFER, 0);
glGenFramebuffers(1, &m_sFramebuffer.m_iFb);
m_sFramebuffer.m_iFbAllocated = true;
m_sFramebuffer.m_vSize = buffer->size;
m_sFramebuffer.bind();
glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_RENDERBUFFER, m_iRBO);
glGenFramebuffers(1, &m_framebuffer.m_fb);
m_framebuffer.m_fbAllocated = true;
m_framebuffer.m_size = buffer->size;
m_framebuffer.bind();
glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_RENDERBUFFER, m_rbo);
if (glCheckFramebufferStatus(GL_FRAMEBUFFER) != GL_FRAMEBUFFER_COMPLETE) {
Debug::log(ERR, "rbo: glCheckFramebufferStatus failed");
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() {
return m_bGood;
return m_good;
}
void CRenderbuffer::bind() {
glBindRenderbuffer(GL_RENDERBUFFER, m_iRBO);
glBindRenderbuffer(GL_RENDERBUFFER, m_rbo);
bindFB();
}
void CRenderbuffer::bindFB() {
m_sFramebuffer.bind();
m_framebuffer.bind();
}
void CRenderbuffer::unbind() {
glBindRenderbuffer(GL_RENDERBUFFER, 0);
m_sFramebuffer.unbind();
m_framebuffer.unbind();
}
CFramebuffer* CRenderbuffer::getFB() {
return &m_sFramebuffer;
return &m_framebuffer;
}

14
src/render/Renderbuffer.hpp
View file

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

321
src/render/Renderer.cpp
View file

@ -48,7 +48,7 @@ extern "C" {
static int cursorTicker(void* data) {
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;
}
@ -62,7 +62,7 @@ CHyprRenderer::CHyprRenderer() {
std::transform(name.begin(), name.end(), name.begin(), tolower);
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,
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);
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,
std::string{DRMV->date, DRMV->date_len}, std::string{DRMV->desc, DRMV->desc_len});
@ -90,27 +90,26 @@ CHyprRenderer::CHyprRenderer() {
drmFreeVersion(DRMV);
}
if (m_bNvidia)
if (m_nvidia)
Debug::log(WARN, "NVIDIA detected, please remember to follow nvidia instructions on the wiki");
// cursor hiding stuff
static auto P = g_pHookSystem->hookDynamic("keyPress", [&](void* self, SCallbackInfo& info, std::any param) {
if (m_sCursorHiddenConditions.hiddenOnKeyboard)
if (m_cursorHiddenConditions.hiddenOnKeyboard)
return;
m_sCursorHiddenConditions.hiddenOnKeyboard = true;
m_cursorHiddenConditions.hiddenOnKeyboard = true;
ensureCursorRenderingMode();
});
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 &&
!m_sCursorHiddenConditions.hiddenOnTimeout)
if (!m_cursorHiddenConditions.hiddenOnKeyboard && m_cursorHiddenConditions.hiddenOnTouch == g_pInputManager->m_lastInputTouch && !m_cursorHiddenConditions.hiddenOnTimeout)
return;
m_sCursorHiddenConditions.hiddenOnKeyboard = false;
m_sCursorHiddenConditions.hiddenOnTimeout = false;
m_sCursorHiddenConditions.hiddenOnTouch = g_pInputManager->m_lastInputTouch;
m_cursorHiddenConditions.hiddenOnKeyboard = false;
m_cursorHiddenConditions.hiddenOnTimeout = false;
m_cursorHiddenConditions.hiddenOnTouch = g_pInputManager->m_lastInputTouch;
ensureCursorRenderingMode();
});
@ -124,19 +123,19 @@ CHyprRenderer::CHyprRenderer() {
});
});
m_pCursorTicker = wl_event_loop_add_timer(g_pCompositor->m_wlEventLoop, cursorTicker, nullptr);
wl_event_source_timer_update(m_pCursorTicker, 500);
m_cursorTicker = wl_event_loop_add_timer(g_pCompositor->m_wlEventLoop, cursorTicker, nullptr);
wl_event_source_timer_update(m_cursorTicker, 500);
m_tRenderUnfocusedTimer = makeShared<CEventLoopTimer>(
m_renderUnfocusedTimer = makeShared<CEventLoopTimer>(
std::nullopt,
[this](SP<CEventLoopTimer> self, void* data) {
static auto PFPS = CConfigValue<Hyprlang::INT>("misc:render_unfocused_fps");
if (m_vRenderUnfocused.empty())
if (m_renderUnfocused.empty())
return;
bool dirty = false;
for (auto& w : m_vRenderUnfocused) {
for (auto& w : m_renderUnfocused) {
if (!w) {
dirty = true;
continue;
@ -153,19 +152,19 @@ CHyprRenderer::CHyprRenderer() {
}
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())
m_tRenderUnfocusedTimer->updateTimeout(std::chrono::milliseconds(1000 / *PFPS));
if (!m_renderUnfocused.empty())
m_renderUnfocusedTimer->updateTimeout(std::chrono::milliseconds(1000 / *PFPS));
},
nullptr);
g_pEventLoopManager->addTimer(m_tRenderUnfocusedTimer);
g_pEventLoopManager->addTimer(m_renderUnfocusedTimer);
}
CHyprRenderer::~CHyprRenderer() {
if (m_pCursorTicker)
wl_event_source_remove(m_pCursorTicker);
if (m_cursorTicker)
wl_event_source_remove(m_cursorTicker);
}
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);
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;
data.color = CHyprColor(0, 0, 0, *PDIMAROUND * renderdata.alpha * renderdata.fadeAlpha);
data.box = monbox;
m_sRenderPass.add(makeShared<CRectPassElement>(data));
m_renderPass.add(makeShared<CRectPassElement>(data));
}
renderdata.pos.x += pWindow->m_floatingOffset.x;
@ -581,7 +580,7 @@ void CHyprRenderer::renderWindow(PHLWINDOW pWindow, PHLMONITOR pMonitor, const T
data.blur = true;
data.blurA = renderdata.fadeAlpha;
data.xray = g_pHyprOpenGL->shouldUseNewBlurOptimizations(nullptr, pWindow);
m_sRenderPass.add(makeShared<CRectPassElement>(data));
m_renderPass.add(makeShared<CRectPassElement>(data));
renderdata.blur = false;
}
@ -592,7 +591,7 @@ void CHyprRenderer::renderWindow(PHLWINDOW pWindow, PHLMONITOR pMonitor, const T
renderdata.texture = s->m_current.texture;
renderdata.surface = s;
renderdata.mainSurface = s == pWindow->m_wlSurface->resource();
m_sRenderPass.add(makeShared<CSurfacePassElement>(renderdata));
m_renderPass.add(makeShared<CSurfacePassElement>(renderdata));
renderdata.surfaceCounter++;
},
nullptr);
@ -609,7 +608,7 @@ void CHyprRenderer::renderWindow(PHLWINDOW pWindow, PHLMONITOR pMonitor, const T
}
if (TRANSFORMERSPRESENT) {
CFramebuffer* last = g_pHyprOpenGL->m_RenderData.currentFB;
CFramebuffer* last = g_pHyprOpenGL->m_renderData.currentFB;
for (auto const& t : pWindow->m_transformers) {
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 (!pWindow->m_isX11) {
@ -660,7 +659,7 @@ void CHyprRenderer::renderWindow(PHLWINDOW pWindow, PHLMONITOR pMonitor, const T
renderdata.texture = s->m_current.texture;
renderdata.surface = s;
renderdata.mainSurface = false;
m_sRenderPass.add(makeShared<CSurfacePassElement>(renderdata));
m_renderPass.add(makeShared<CSurfacePassElement>(renderdata));
renderdata.surfaceCounter++;
},
data);
@ -681,11 +680,11 @@ void CHyprRenderer::renderWindow(PHLWINDOW pWindow, PHLMONITOR pMonitor, const T
}
// for plugins
g_pHyprOpenGL->m_RenderData.currentWindow = pWindow;
g_pHyprOpenGL->m_renderData.currentWindow = pWindow;
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) {
@ -700,9 +699,9 @@ void CHyprRenderer::renderLayer(PHLLS pLayer, PHLMONITOR pMonitor, const Time::s
if (*PDIMAROUND && pLayer->m_dimAround && !m_bRenderingSnapshot && !popups) {
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());
m_sRenderPass.add(makeShared<CRectPassElement>(data));
m_renderPass.add(makeShared<CRectPassElement>(data));
}
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.surface = s;
renderdata.mainSurface = s == pLayer->m_surface->resource();
m_sRenderPass.add(makeShared<CSurfacePassElement>(renderdata));
m_renderPass.add(makeShared<CSurfacePassElement>(renderdata));
renderdata.surfaceCounter++;
},
&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.surface = popup->m_wlSurface->resource();
renderdata.mainSurface = false;
m_sRenderPass.add(makeShared<CSurfacePassElement>(renderdata));
m_renderPass.add(makeShared<CSurfacePassElement>(renderdata));
renderdata.surfaceCounter++;
},
&renderdata);
@ -798,7 +797,7 @@ void CHyprRenderer::renderIMEPopup(CInputPopup* pPopup, PHLMONITOR pMonitor, con
renderdata.texture = s->m_current.texture;
renderdata.surface = s;
renderdata.mainSurface = s == SURF;
m_sRenderPass.add(makeShared<CSurfacePassElement>(renderdata));
m_renderPass.add(makeShared<CSurfacePassElement>(renderdata));
renderdata.surfaceCounter++;
},
&renderdata);
@ -819,7 +818,7 @@ void CHyprRenderer::renderSessionLockSurface(WP<SSessionLockSurface> pSurface, P
renderdata.texture = s->m_current.texture;
renderdata.surface = s;
renderdata.mainSurface = s == pSurface->surface->surface();
m_sRenderPass.add(makeShared<CSurfacePassElement>(renderdata));
m_renderPass.add(makeShared<CSurfacePassElement>(renderdata));
renderdata.surfaceCounter++;
},
&renderdata);
@ -853,12 +852,12 @@ void CHyprRenderer::renderAllClientsForWorkspace(PHLMONITOR pMonitor, PHLWORKSPA
RENDERMODIFDATA.modifs.emplace_back(std::make_pair<>(SRenderModifData::eRenderModifType::RMOD_TYPE_SCALE, scale));
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] {
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.
if (*PRENDERTEX /* inverted cfg flag */)
m_sRenderPass.add(makeShared<CClearPassElement>(CClearPassElement::SClearData{CHyprColor(*PBACKGROUNDCOLOR)}));
m_renderPass.add(makeShared<CClearPassElement>(CClearPassElement::SClearData{CHyprColor(*PBACKGROUNDCOLOR)}));
else
g_pHyprOpenGL->clearWithTex(); // will apply the hypr "wallpaper"
@ -888,7 +887,7 @@ void CHyprRenderer::renderAllClientsForWorkspace(PHLMONITOR pMonitor, PHLWORKSPA
if (!*PXPMODE) {
if (*PRENDERTEX /* inverted cfg flag */)
m_sRenderPass.add(makeShared<CClearPassElement>(CClearPassElement::SClearData{CHyprColor(*PBACKGROUNDCOLOR)}));
m_renderPass.add(makeShared<CClearPassElement>(CClearPassElement::SClearData{CHyprColor(*PBACKGROUNDCOLOR)}));
else
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.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) {
@ -929,7 +928,7 @@ void CHyprRenderer::renderAllClientsForWorkspace(PHLMONITOR pMonitor, PHLWORKSPA
data.blur = true;
data.blurA = (ANIMOUT ? (1.0 - SPECIALANIMPROGRS) : SPECIALANIMPROGRS);
g_pHyprRenderer->m_sRenderPass.add(makeShared<CRectPassElement>(data));
g_pHyprRenderer->m_renderPass.add(makeShared<CRectPassElement>(data));
}
break;
@ -1027,15 +1026,15 @@ void CHyprRenderer::renderSessionLockMissing(PHLMONITOR pMonitor) {
if (ANY_PRESENT) {
// 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 {
// 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
if (g_pHyprOpenGL->m_pLockTtyTextTexture) {
CBox texbox = {{}, g_pHyprOpenGL->m_pLockTtyTextTexture->m_vSize};
g_pHyprOpenGL->renderTexture(g_pHyprOpenGL->m_pLockTtyTextTexture, texbox, 1.F);
if (g_pHyprOpenGL->m_lockTtyTextTexture) {
CBox texbox = {{}, g_pHyprOpenGL->m_lockTtyTextTexture->m_size};
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.primarySurfaceUVBottomRight = uvBR;
g_pHyprOpenGL->m_renderData.primarySurfaceUVTopLeft = uvTL;
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
g_pHyprOpenGL->m_RenderData.primarySurfaceUVTopLeft = Vector2D(-1, -1);
g_pHyprOpenGL->m_RenderData.primarySurfaceUVBottomRight = Vector2D(-1, -1);
g_pHyprOpenGL->m_renderData.primarySurfaceUVTopLeft = Vector2D(-1, -1);
g_pHyprOpenGL->m_renderData.primarySurfaceUVBottomRight = Vector2D(-1, -1);
}
if (!main || !pWindow)
@ -1132,17 +1131,17 @@ void CHyprRenderer::calculateUVForSurface(PHLWINDOW pWindow, SP<CWLSurfaceResour
uvBR.y = uvBR.y * (maxSize.y / geom.height);
}
g_pHyprOpenGL->m_RenderData.primarySurfaceUVTopLeft = uvTL;
g_pHyprOpenGL->m_RenderData.primarySurfaceUVBottomRight = uvBR;
g_pHyprOpenGL->m_renderData.primarySurfaceUVTopLeft = uvTL;
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
g_pHyprOpenGL->m_RenderData.primarySurfaceUVTopLeft = Vector2D(-1, -1);
g_pHyprOpenGL->m_RenderData.primarySurfaceUVBottomRight = Vector2D(-1, -1);
g_pHyprOpenGL->m_renderData.primarySurfaceUVTopLeft = Vector2D(-1, -1);
g_pHyprOpenGL->m_renderData.primarySurfaceUVBottomRight = Vector2D(-1, -1);
}
} else {
g_pHyprOpenGL->m_RenderData.primarySurfaceUVTopLeft = Vector2D(-1, -1);
g_pHyprOpenGL->m_RenderData.primarySurfaceUVBottomRight = Vector2D(-1, -1);
g_pHyprOpenGL->m_renderData.primarySurfaceUVTopLeft = Vector2D(-1, -1);
g_pHyprOpenGL->m_renderData.primarySurfaceUVBottomRight = Vector2D(-1, -1);
}
}
@ -1173,15 +1172,15 @@ void CHyprRenderer::renderMonitor(PHLMONITOR pMonitor) {
if (firstLaunch) {
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) {
zoomInFactorFirstLaunch = 1.f;
firstLaunchAnimActive = false;
} 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);
}
} else {
@ -1196,7 +1195,7 @@ void CHyprRenderer::renderMonitor(PHLMONITOR pMonitor) {
if (!g_pCompositor->m_sessionActive)
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
g_pCompositor->sanityCheckWorkspaces();
@ -1224,7 +1223,7 @@ void CHyprRenderer::renderMonitor(PHLMONITOR pMonitor) {
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");
return;
}
@ -1295,14 +1294,14 @@ void CHyprRenderer::renderMonitor(PHLMONITOR pMonitor) {
}
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
g_pHyprOpenGL->m_RenderData.mouseZoomFactor = 1.f;
g_pHyprOpenGL->m_renderData.mouseZoomFactor = 1.f;
if (zoomInFactorFirstLaunch > 1.f) {
g_pHyprOpenGL->m_RenderData.mouseZoomFactor = zoomInFactorFirstLaunch;
g_pHyprOpenGL->m_RenderData.mouseZoomUseMouse = false;
g_pHyprOpenGL->m_RenderData.useNearestNeighbor = false;
g_pHyprOpenGL->m_renderData.mouseZoomFactor = zoomInFactorFirstLaunch;
g_pHyprOpenGL->m_renderData.mouseZoomUseMouse = false;
g_pHyprOpenGL->m_renderData.useNearestNeighbor = false;
pMonitor->m_forceFullFrames = 10;
}
@ -1361,7 +1360,7 @@ void CHyprRenderer::renderMonitor(PHLMONITOR pMonitor) {
CRectPassElement::SRectData data;
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);
m_sRenderPass.add(makeShared<CRectPassElement>(data));
m_renderPass.add(makeShared<CRectPassElement>(data));
damageBlinkCleanup = 1;
} else if (*PDAMAGEBLINK) {
damageBlinkCleanup++;
@ -1381,7 +1380,7 @@ void CHyprRenderer::renderMonitor(PHLMONITOR pMonitor) {
if (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);
@ -1390,7 +1389,7 @@ void CHyprRenderer::renderMonitor(PHLMONITOR pMonitor) {
TRACY_GPU_COLLECT;
CRegion frameDamage{g_pHyprOpenGL->m_RenderData.damage};
CRegion frameDamage{g_pHyprOpenGL->m_renderData.damage};
const auto TRANSFORM = invertTransform(pMonitor->m_transform);
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) {
m_bCursorHasSurface = surf;
m_cursorHasSurface = surf;
m_sLastCursorData.name = "";
m_sLastCursorData.surf = surf;
m_sLastCursorData.hotspotX = hotspotX;
m_sLastCursorData.hotspotY = hotspotY;
m_lastCursorData.name = "";
m_lastCursorData.surf = surf;
m_lastCursorData.hotspotX = hotspotX;
m_lastCursorData.hotspotY = hotspotY;
if (m_bCursorHidden && !force)
if (m_cursorHidden && !force)
return;
g_pCursorManager->setCursorSurface(surf, {hotspotX, hotspotY});
}
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;
m_sLastCursorData.name = name;
m_sLastCursorData.surf.reset();
m_lastCursorData.name = name;
m_lastCursorData.surf.reset();
if (m_bCursorHidden && !force)
if (m_cursorHidden && !force)
return;
g_pCursorManager->setCursorFromName(name);
@ -1998,18 +1997,18 @@ void CHyprRenderer::ensureCursorRenderingMode() {
static auto PHIDEONKEY = CConfigValue<Hyprlang::INT>("cursor:hide_on_key_press");
if (*PCURSORTIMEOUT <= 0)
m_sCursorHiddenConditions.hiddenOnTimeout = false;
m_cursorHiddenConditions.hiddenOnTimeout = false;
if (*PHIDEONTOUCH == 0)
m_sCursorHiddenConditions.hiddenOnTouch = false;
m_cursorHiddenConditions.hiddenOnTouch = false;
if (*PHIDEONKEY == 0)
m_sCursorHiddenConditions.hiddenOnKeyboard = false;
m_cursorHiddenConditions.hiddenOnKeyboard = false;
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;
if (HIDE) {
@ -2040,26 +2039,26 @@ void CHyprRenderer::ensureCursorRenderingMode() {
void CHyprRenderer::setCursorHidden(bool hide) {
if (hide == m_bCursorHidden)
if (hide == m_cursorHidden)
return;
m_bCursorHidden = hide;
m_cursorHidden = hide;
if (hide) {
g_pPointerManager->resetCursorImage();
return;
}
if (m_sLastCursorData.surf.has_value())
setCursorSurface(m_sLastCursorData.surf.value(), m_sLastCursorData.hotspotX, m_sLastCursorData.hotspotY, true);
else if (!m_sLastCursorData.name.empty())
setCursorFromName(m_sLastCursorData.name, true);
if (m_lastCursorData.surf.has_value())
setCursorSurface(m_lastCursorData.surf.value(), m_lastCursorData.hotspotX, m_lastCursorData.hotspotY, true);
else if (!m_lastCursorData.name.empty())
setCursorFromName(m_lastCursorData.name, true);
else
setCursorFromName("left_ptr", true);
}
bool CHyprRenderer::shouldRenderCursor() {
return !m_bCursorHidden && m_bCursorHasSurface;
return !m_cursorHidden && m_cursorHasSurface;
}
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) {
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);
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);
wl_event_source_timer_update(g_pHyprRenderer->m_pCrashingLoop, 1000);
wl_event_source_timer_update(g_pHyprRenderer->m_crashingLoop, 1000);
return 1;
}
@ -2098,13 +2097,13 @@ static int handleCrashLoop(void* data) {
void CHyprRenderer::initiateManualCrash() {
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);
wl_event_source_timer_update(m_pCrashingLoop, 1000);
m_crashingLoop = wl_event_loop_add_timer(g_pCompositor->m_wlEventLoop, handleCrashLoop, nullptr);
wl_event_source_timer_update(m_crashingLoop, 1000);
m_bCrashingInProgress = true;
m_fCrashingDistort = 0.5;
m_crashingInProgress = true;
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"));
@ -2169,9 +2168,9 @@ void CHyprRenderer::recheckSolitaryForMonitor(PHLMONITOR pMonitor) {
}
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;
auto buf = makeShared<CRenderbuffer>(buffer, fmt);
@ -2179,7 +2178,7 @@ SP<CRenderbuffer> CHyprRenderer::getOrCreateRenderbuffer(SP<Aquamarine::IBuffer>
if (!buf->good())
return nullptr;
m_vRenderbuffers.emplace_back(buf);
m_renderbuffers.emplace_back(buf);
return buf;
}
@ -2187,26 +2186,26 @@ void CHyprRenderer::makeEGLCurrent() {
if (!g_pCompositor || !g_pHyprOpenGL)
return;
if (eglGetCurrentContext() != g_pHyprOpenGL->m_pEglContext)
eglMakeCurrent(g_pHyprOpenGL->m_pEglDisplay, EGL_NO_SURFACE, EGL_NO_SURFACE, g_pHyprOpenGL->m_pEglContext);
if (eglGetCurrentContext() != g_pHyprOpenGL->m_eglContext)
eglMakeCurrent(g_pHyprOpenGL->m_eglDisplay, EGL_NO_SURFACE, EGL_NO_SURFACE, g_pHyprOpenGL->m_eglContext);
}
void CHyprRenderer::unsetEGL() {
if (!g_pHyprOpenGL)
return;
eglMakeCurrent(g_pHyprOpenGL->m_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) {
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) {
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;
if (!buffer) {
m_pCurrentBuffer = pMonitor->m_output->swapchain->next(nullptr);
if (!m_pCurrentBuffer) {
m_currentBuffer = pMonitor->m_output->swapchain->next(nullptr);
if (!m_currentBuffer) {
Debug::log(ERR, "Failed to acquire swapchain buffer for {}", pMonitor->m_name);
return false;
}
} else
m_pCurrentBuffer = buffer;
m_currentBuffer = buffer;
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) {
Debug::log(ERR, "getOrCreateRenderbuffer failed for {}", pMonitor->m_name);
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);
return false;
}
@ -2248,9 +2247,9 @@ bool CHyprRenderer::beginRender(PHLMONITOR pMonitor, CRegion& damage, eRenderMod
pMonitor->m_damage.rotate();
}
m_pCurrentRenderbuffer->bind();
m_currentRenderbuffer->bind();
if (simple)
g_pHyprOpenGL->beginSimple(pMonitor, damage, m_pCurrentRenderbuffer);
g_pHyprOpenGL->beginSimple(pMonitor, damage, m_currentRenderbuffer);
else
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) {
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");
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]() {
if (m_pCurrentRenderbuffer)
m_pCurrentRenderbuffer->unbind();
m_pCurrentRenderbuffer = nullptr;
m_pCurrentBuffer = nullptr;
if (m_currentRenderbuffer)
m_currentRenderbuffer->unbind();
m_currentRenderbuffer = 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();
else {
g_pHyprOpenGL->m_RenderData.pMonitor.reset();
g_pHyprOpenGL->m_RenderData.mouseZoomFactor = 1.f;
g_pHyprOpenGL->m_RenderData.mouseZoomUseMouse = true;
g_pHyprOpenGL->m_renderData.pMonitor.reset();
g_pHyprOpenGL->m_renderData.mouseZoomFactor = 1.f;
g_pHyprOpenGL->m_renderData.mouseZoomUseMouse = true;
}
// send all queued opengl commands so rendering starts happening immediately
glFlush();
if (m_eRenderMode == RENDER_MODE_FULL_FAKE)
if (m_renderMode == RENDER_MODE_FULL_FAKE)
return;
if (m_eRenderMode == RENDER_MODE_NORMAL)
PMONITOR->m_output->state->setBuffer(m_pCurrentBuffer);
if (m_renderMode == RENDER_MODE_NORMAL)
PMONITOR->m_output->state->setBuffer(m_currentBuffer);
UP<CEGLSync> eglSync = CEGLSync::create();
if (eglSync && eglSync->isValid()) {
for (auto const& buf : usedAsyncBuffers) {
for (auto const& buf : m_usedAsyncBuffers) {
for (const auto& releaser : buf->m_syncReleasers) {
releaser->addSyncFileFd(eglSync->fd());
}
}
// 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
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();
if (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_output->state->setExplicitInFence(PMONITOR->m_inFence.get());
}
@ -2317,22 +2316,22 @@ void CHyprRenderer::endRender(const std::function<void()>& renderingDoneCallback
if (isNvidia() && *PNVIDIAANTIFLICKER)
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)
renderingDoneCallback();
}
}
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() {
return m_pCurrentRenderbuffer;
return m_currentRenderbuffer;
}
bool CHyprRenderer::isNvidia() {
return m_bNvidia;
return m_nvidia;
}
SExplicitSyncSettings CHyprRenderer::getExplicitSyncSettings(SP<Aquamarine::IOutput> output) {
@ -2353,7 +2352,7 @@ SExplicitSyncSettings CHyprRenderer::getExplicitSyncSettings(SP<Aquamarine::IOut
if (*PENABLEEXPLICIT == 2 /* auto */)
settings.explicitEnabled = true;
if (*PENABLEEXPLICITKMS == 2 /* auto */) {
if (!m_bNvidia)
if (!m_nvidia)
settings.explicitKMSEnabled = true;
else {
settings.explicitKMSEnabled = isNvidiaDriverVersionAtLeast(560);
@ -2365,13 +2364,13 @@ SExplicitSyncSettings CHyprRenderer::getExplicitSyncSettings(SP<Aquamarine::IOut
void CHyprRenderer::addWindowToRenderUnfocused(PHLWINDOW window) {
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;
m_vRenderUnfocused.emplace_back(window);
m_renderUnfocused.emplace_back(window);
if (!m_tRenderUnfocusedTimer->armed())
m_tRenderUnfocusedTimer->updateTimeout(std::chrono::milliseconds(1000 / *PFPS));
if (!m_renderUnfocusedTimer->armed())
m_renderUnfocusedTimer->updateTimeout(std::chrono::milliseconds(1000 / *PFPS));
}
void CHyprRenderer::makeRawWindowSnapshot(PHLWINDOW pWindow, CFramebuffer* pFramebuffer) {
@ -2389,7 +2388,7 @@ void CHyprRenderer::makeRawWindowSnapshot(PHLWINDOW pWindow, CFramebuffer* pFram
makeEGLCurrent();
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);
@ -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.
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
@ -2437,7 +2436,7 @@ void CHyprRenderer::makeWindowSnapshot(PHLWINDOW pWindow) {
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);
@ -2481,7 +2480,7 @@ void CHyprRenderer::makeLayerSnapshot(PHLLS pLayer) {
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);
@ -2509,10 +2508,10 @@ void CHyprRenderer::renderSnapshot(PHLWINDOW pWindow) {
PHLWINDOWREF ref{pWindow};
if (!g_pHyprOpenGL->m_mWindowFramebuffers.contains(ref))
if (!g_pHyprOpenGL->m_windowFramebuffers.contains(ref))
return;
const auto FBDATA = &g_pHyprOpenGL->m_mWindowFramebuffers.at(ref);
const auto FBDATA = &g_pHyprOpenGL->m_windowFramebuffers.at(ref);
if (!FBDATA->getTexture())
return;
@ -2536,10 +2535,10 @@ void CHyprRenderer::renderSnapshot(PHLWINDOW pWindow) {
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());
m_sRenderPass.add(makeShared<CRectPassElement>(data));
m_renderPass.add(makeShared<CRectPassElement>(data));
damageMonitor(PMONITOR);
}
@ -2550,14 +2549,14 @@ void CHyprRenderer::renderSnapshot(PHLWINDOW pWindow) {
data.a = pWindow->m_alpha->value();
data.damage = fakeDamage;
m_sRenderPass.add(makeShared<CTexPassElement>(data));
m_renderPass.add(makeShared<CTexPassElement>(data));
}
void CHyprRenderer::renderSnapshot(PHLLS pLayer) {
if (!g_pHyprOpenGL->m_mLayerFramebuffers.contains(pLayer))
if (!g_pHyprOpenGL->m_layerFramebuffers.contains(pLayer))
return;
const auto FBDATA = &g_pHyprOpenGL->m_mLayerFramebuffers.at(pLayer);
const auto FBDATA = &g_pHyprOpenGL->m_layerFramebuffers.at(pLayer);
if (!FBDATA->getTexture())
return;
@ -2586,5 +2585,5 @@ void CHyprRenderer::renderSnapshot(PHLLS pLayer) {
data.a = pLayer->m_alpha->value();
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_bRenderingSnapshot = false;
PHLMONITORREF m_pMostHzMonitor;
bool m_bDirectScanoutBlocked = false;
PHLMONITORREF m_mostHzMonitor;
bool m_directScanoutBlocked = false;
void setSurfaceScanoutMode(SP<CWLSurfaceResource> surface, PHLMONITOR monitor); // nullptr monitor resets
void initiateManualCrash();
bool m_bCrashingInProgress = false;
float m_fCrashingDistort = 0.5f;
wl_event_source* m_pCrashingLoop = nullptr;
wl_event_source* m_pCursorTicker = nullptr;
bool m_crashingInProgress = false;
float m_crashingDistort = 0.5f;
wl_event_source* m_crashingLoop = nullptr;
wl_event_source* m_cursorTicker = nullptr;
CTimer m_tRenderTimer;
CTimer m_renderTimer;
std::vector<CHLBufferReference> usedAsyncBuffers;
std::vector<CHLBufferReference> m_usedAsyncBuffers;
struct {
int hotspotX = 0;
int hotspotY = 0;
std::optional<SP<CWLSurface>> surf;
std::string name;
} m_sLastCursorData;
} m_lastCursorData;
CRenderPass m_sRenderPass = {};
CRenderPass m_renderPass = {};
private:
void arrangeLayerArray(PHLMONITOR, const std::vector<PHLLSREF>&, bool, CBox*);
@ -131,23 +131,23 @@ class CHyprRenderer {
bool commitPendingAndDoExplicitSync(PHLMONITOR pMonitor);
bool m_bCursorHidden = false;
bool m_bCursorHasSurface = false;
SP<CRenderbuffer> m_pCurrentRenderbuffer = nullptr;
SP<Aquamarine::IBuffer> m_pCurrentBuffer = nullptr;
eRenderMode m_eRenderMode = RENDER_MODE_NORMAL;
bool m_bNvidia = false;
bool m_cursorHidden = false;
bool m_cursorHasSurface = false;
SP<CRenderbuffer> m_currentRenderbuffer = nullptr;
SP<Aquamarine::IBuffer> m_currentBuffer = nullptr;
eRenderMode m_renderMode = RENDER_MODE_NORMAL;
bool m_nvidia = false;
struct {
bool hiddenOnTouch = false;
bool hiddenOnTimeout = false;
bool hiddenOnKeyboard = false;
} m_sCursorHiddenConditions;
} m_cursorHiddenConditions;
SP<CRenderbuffer> getOrCreateRenderbuffer(SP<Aquamarine::IBuffer> buffer, uint32_t fmt);
std::vector<SP<CRenderbuffer>> m_vRenderbuffers;
std::vector<PHLWINDOWREF> m_vRenderUnfocused;
SP<CEventLoopTimer> m_tRenderUnfocusedTimer;
std::vector<SP<CRenderbuffer>> m_renderbuffers;
std::vector<PHLWINDOWREF> m_renderUnfocused;
SP<CEventLoopTimer> m_renderUnfocusedTimer;
friend class CHyprOpenGLImpl;
friend class CToplevelExportFrame;

3
src/render/Shader.hpp
View file

@ -78,7 +78,4 @@ class CShader {
GLint noise = -1;
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();
}
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_);
}
@ -23,11 +23,11 @@ CTexture::CTexture(const Aquamarine::SDMABUFAttrs& attrs, void* 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)
return;
m_bOpaque = buffer->opaque;
m_opaque = buffer->opaque;
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);
m_iDrmFormat = fmt;
m_drmFormat = fmt;
createFromShm(fmt, pixelData, bufLen, shm.size);
return;
@ -64,12 +64,12 @@ void CTexture::createFromShm(uint32_t drmFormat, uint8_t* pixels, uint32_t strid
const auto format = NFormatUtils::getPixelFormatFromDRM(drmFormat);
ASSERT(format);
m_iType = format->withAlpha ? TEXTURE_RGBA : TEXTURE_RGBX;
m_vSize = size_;
m_type = format->withAlpha ? TEXTURE_RGBA : TEXTURE_RGBX;
m_size = size_;
m_isSynchronous = true;
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_T, GL_CLAMP_TO_EDGE));
#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(glBindTexture(GL_TEXTURE_2D, 0));
if (m_bKeepDataCopy) {
m_vDataCopy.resize(stride * size_.y);
memcpy(m_vDataCopy.data(), pixels, stride * size_.y);
if (m_keepDataCopy) {
m_dataCopy.resize(stride * size_.y);
memcpy(m_dataCopy.data(), pixels, stride * size_.y);
}
}
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");
return;
}
m_bOpaque = NFormatUtils::isFormatOpaque(attrs.format);
m_iTarget = GL_TEXTURE_2D;
m_iType = TEXTURE_RGBA;
m_vSize = attrs.size;
m_iType = NFormatUtils::isFormatOpaque(attrs.format) ? TEXTURE_RGBX : TEXTURE_RGBA;
m_opaque = NFormatUtils::isFormatOpaque(attrs.format);
m_target = GL_TEXTURE_2D;
m_type = TEXTURE_RGBA;
m_size = attrs.size;
m_type = NFormatUtils::isFormatOpaque(attrs.format) ? TEXTURE_RGBX : TEXTURE_RGBA;
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_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));
}
@ -116,9 +116,9 @@ void CTexture::update(uint32_t drmFormat, uint8_t* pixels, uint32_t stride, cons
const auto format = NFormatUtils::getPixelFormatFromDRM(drmFormat);
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
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);
if (m_bKeepDataCopy) {
m_vDataCopy.resize(stride * m_vSize.y);
memcpy(m_vDataCopy.data(), pixels, stride * m_vSize.y);
if (m_keepDataCopy) {
m_dataCopy.resize(stride * m_size.y);
memcpy(m_dataCopy.data(), pixels, stride * m_size.y);
}
}
void CTexture::destroyTexture() {
if (m_iTexID) {
GLCALL(glDeleteTextures(1, &m_iTexID));
m_iTexID = 0;
if (m_texID) {
GLCALL(glDeleteTextures(1, &m_texID));
m_texID = 0;
}
if (m_pEglImage)
g_pHyprOpenGL->m_sProc.eglDestroyImageKHR(g_pHyprOpenGL->m_pEglDisplay, m_pEglImage);
m_pEglImage = nullptr;
if (m_eglImage)
g_pHyprOpenGL->m_proc.eglDestroyImageKHR(g_pHyprOpenGL->m_eglDisplay, m_eglImage);
m_eglImage = nullptr;
}
void CTexture::allocate() {
if (!m_iTexID)
GLCALL(glGenTextures(1, &m_iTexID));
if (!m_texID)
GLCALL(glGenTextures(1, &m_texID));
}
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);
const std::vector<uint8_t>& dataCopy();
eTextureType m_iType = TEXTURE_RGBA;
GLenum m_iTarget = GL_TEXTURE_2D;
GLuint m_iTexID = 0;
Vector2D m_vSize = {};
void* m_pEglImage = nullptr;
eTransform m_eTransform = HYPRUTILS_TRANSFORM_NORMAL;
bool m_bOpaque = false;
uint32_t m_iDrmFormat = 0; // for shm
eTextureType m_type = TEXTURE_RGBA;
GLenum m_target = GL_TEXTURE_2D;
GLuint m_texID = 0;
Vector2D m_size = {};
void* m_eglImage = nullptr;
eTransform m_transform = HYPRUTILS_TRANSFORM_NORMAL;
bool m_opaque = false;
uint32_t m_drmFormat = 0; // for shm
bool m_isSynchronous = false;
private:
void createFromShm(uint32_t drmFormat, uint8_t* pixels, uint32_t stride, const Vector2D& size);
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 "../../managers/HookSystemManager.hpp"
CHyprBorderDecoration::CHyprBorderDecoration(PHLWINDOW pWindow) : IHyprWindowDecoration(pWindow), m_pWindow(pWindow) {
CHyprBorderDecoration::CHyprBorderDecoration(PHLWINDOW pWindow) : IHyprWindowDecoration(pWindow), m_window(pWindow) {
;
}
SDecorationPositioningInfo CHyprBorderDecoration::getPositioningInfo() {
const auto BORDERSIZE = m_pWindow->getRealBorderSize();
m_seExtents = {{BORDERSIZE, BORDERSIZE}, {BORDERSIZE, BORDERSIZE}};
const auto BORDERSIZE = m_window->getRealBorderSize();
m_extents = {{BORDERSIZE, BORDERSIZE}, {BORDERSIZE, BORDERSIZE}};
if (doesntWantBorders())
m_seExtents = {{}, {}};
m_extents = {{}, {}};
SDecorationPositioningInfo info;
info.priority = 10000;
info.policy = DECORATION_POSITION_STICKY;
info.desiredExtents = m_seExtents;
info.desiredExtents = m_extents;
info.reserved = true;
info.edges = DECORATION_EDGE_BOTTOM | DECORATION_EDGE_LEFT | DECORATION_EDGE_RIGHT | DECORATION_EDGE_TOP;
m_seReportedExtents = m_seExtents;
m_reportedExtents = m_extents;
return info;
}
void CHyprBorderDecoration::onPositioningReply(const SDecorationPositioningReply& reply) {
m_bAssignedGeometry = reply.assignedGeometry;
m_assignedGeometry = reply.assignedGeometry;
}
CBox CHyprBorderDecoration::assignedBoxGlobal() {
CBox box = m_bAssignedGeometry;
box.translate(g_pDecorationPositioner->getEdgeDefinedPoint(DECORATION_EDGE_BOTTOM | DECORATION_EDGE_LEFT | DECORATION_EDGE_RIGHT | DECORATION_EDGE_TOP, m_pWindow.lock()));
CBox box = m_assignedGeometry;
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)
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);
}
@ -49,30 +49,30 @@ void CHyprBorderDecoration::draw(PHLMONITOR pMonitor, float const& a) {
if (doesntWantBorders())
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;
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)
return;
auto grad = m_pWindow->m_realBorderColor;
const bool ANIMATED = m_pWindow->m_borderFadeAnimationProgress->isBeingAnimated();
auto grad = m_window->m_realBorderColor;
const bool ANIMATED = m_window->m_borderFadeAnimationProgress->isBeingAnimated();
if (m_pWindow->m_borderAngleAnimationProgress->enabled()) {
grad.m_angle += m_pWindow->m_borderAngleAnimationProgress->value() * M_PI * 2;
if (m_window->m_borderAngleAnimationProgress->enabled()) {
grad.m_angle += m_window->m_borderAngleAnimationProgress->value() * M_PI * 2;
grad.m_angle = normalizeAngleRad(grad.m_angle);
// 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.
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();
const auto ROUNDING = m_pWindow->rounding() * pMonitor->m_scale;
const auto ROUNDINGPOWER = m_pWindow->roundingPower();
int borderSize = m_window->getRealBorderSize();
const auto ROUNDING = m_window->rounding() * pMonitor->m_scale;
const auto ROUNDINGPOWER = m_window->roundingPower();
CBorderPassElement::SBorderData data;
data.box = windowBox;
@ -84,12 +84,12 @@ void CHyprBorderDecoration::draw(PHLMONITOR pMonitor, float const& a) {
if (ANIMATED) {
data.hasGrad2 = true;
data.grad1 = m_pWindow->m_realBorderColorPrevious;
data.grad1 = m_window->m_realBorderColorPrevious;
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() {
@ -97,32 +97,32 @@ eDecorationType CHyprBorderDecoration::getDecorationType() {
}
void CHyprBorderDecoration::updateWindow(PHLWINDOW) {
auto borderSize = m_pWindow->getRealBorderSize();
auto borderSize = m_window->getRealBorderSize();
if (borderSize == m_iLastBorderSize)
if (borderSize == m_lastBorderSize)
return;
if (borderSize <= 0 && m_iLastBorderSize <= 0)
if (borderSize <= 0 && m_lastBorderSize <= 0)
return;
m_iLastBorderSize = borderSize;
m_lastBorderSize = borderSize;
g_pDecorationPositioner->repositionDeco(this);
}
void CHyprBorderDecoration::damageEntire() {
if (!validMapped(m_pWindow))
if (!validMapped(m_window))
return;
auto surfaceBox = m_pWindow->getWindowMainSurfaceBox();
const auto ROUNDING = m_pWindow->rounding();
auto surfaceBox = m_window->getWindowMainSurfaceBox();
const auto ROUNDING = m_window->rounding();
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;
if (PWINDOWWORKSPACE && PWINDOWWORKSPACE->m_renderOffset->isBeingAnimated() && !m_pWindow->m_pinned)
const auto PWINDOWWORKSPACE = m_window->m_workspace;
if (PWINDOWWORKSPACE && PWINDOWWORKSPACE->m_renderOffset->isBeingAnimated() && !m_window->m_pinned)
surfaceBox.translate(PWINDOWWORKSPACE->m_renderOffset->value());
surfaceBox.translate(m_pWindow->m_floatingOffset);
surfaceBox.translate(m_window->m_floatingOffset);
CBox surfaceBoxExpandedBorder = surfaceBox;
surfaceBoxExpandedBorder.expand(BORDERSIZE);
@ -133,7 +133,7 @@ void CHyprBorderDecoration::damageEntire() {
borderRegion.subtract(surfaceBoxShrunkRounding);
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});
borderRegion.subtract(monitorRegion);
}
@ -157,5 +157,5 @@ std::string CHyprBorderDecoration::getDisplayName() {
}
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();
private:
SBoxExtents m_seExtents;
SBoxExtents m_seReportedExtents;
SBoxExtents m_extents;
SBoxExtents m_reportedExtents;
PHLWINDOWREF m_pWindow;
PHLWINDOWREF m_window;
Vector2D m_vLastWindowPos;
Vector2D m_vLastWindowSize;
CBox m_assignedGeometry = {0};
CBox m_bAssignedGeometry = {0};
int m_iLastBorderSize = -1;
int m_lastBorderSize = -1;
CBox assignedBoxGlobal();
bool doesntWantBorders();

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

@ -5,7 +5,7 @@
#include "../pass/ShadowPassElement.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 info;
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;
m_seReportedExtents = m_seExtents;
m_reportedExtents = m_extents;
return info;
}
void CHyprDropShadowDecoration::onPositioningReply(const SDecorationPositioningReply& reply) {
updateWindow(m_pWindow.lock());
updateWindow(m_window.lock());
}
uint64_t CHyprDropShadowDecoration::getDecorationFlags() {
@ -41,11 +41,11 @@ void CHyprDropShadowDecoration::damageEntire() {
if (*PSHADOWS != 1)
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,
PWINDOW->m_realSize->value().x + m_seExtents.topLeft.x + m_seExtents.bottomRight.x,
PWINDOW->m_realSize->value().y + m_seExtents.topLeft.y + m_seExtents.bottomRight.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_extents.topLeft.x + m_extents.bottomRight.x,
PWINDOW->m_realSize->value().y + m_extents.topLeft.y + m_extents.bottomRight.y};
const auto PWORKSPACE = PWINDOW->m_workspace;
if (PWORKSPACE && PWORKSPACE->m_renderOffset->isBeingAnimated() && !PWINDOW->m_pinned)
@ -77,24 +77,24 @@ void CHyprDropShadowDecoration::damageEntire() {
}
void CHyprDropShadowDecoration::updateWindow(PHLWINDOW pWindow) {
const auto PWINDOW = m_pWindow.lock();
const auto PWINDOW = m_window.lock();
m_vLastWindowPos = PWINDOW->m_realPosition->value();
m_vLastWindowSize = PWINDOW->m_realSize->value();
m_lastWindowPos = PWINDOW->m_realPosition->value();
m_lastWindowSize = PWINDOW->m_realSize->value();
m_bLastWindowBox = {m_vLastWindowPos.x, m_vLastWindowPos.y, m_vLastWindowSize.x, m_vLastWindowSize.y};
m_bLastWindowBoxWithDecos = g_pDecorationPositioner->getBoxWithIncludedDecos(pWindow);
m_lastWindowBox = {m_lastWindowPos.x, m_lastWindowPos.y, m_lastWindowSize.x, m_lastWindowSize.y};
m_lastWindowBoxWithDecos = g_pDecorationPositioner->getBoxWithIncludedDecos(pWindow);
}
void CHyprDropShadowDecoration::draw(PHLMONITOR pMonitor, float const& a) {
CShadowPassElement::SShadowData data;
data.deco = this;
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) {
const auto PWINDOW = m_pWindow.lock();
const auto PWINDOW = m_window.lock();
if (!validMapped(PWINDOW))
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();
// draw the shadow
CBox fullBox = m_bLastWindowBoxWithDecos;
CBox fullBox = m_lastWindowBoxWithDecos;
fullBox.translate(-pMonitor->m_position + WORKSPACEOFFSET);
fullBox.x -= *PSHADOWSIZE;
fullBox.y -= *PSHADOWSIZE;
@ -137,10 +137,10 @@ void CHyprDropShadowDecoration::render(PHLMONITOR pMonitor, float const& a) {
fullBox.scaleFromCenter(SHADOWSCALE).translate({(*PSHADOWOFFSET).x, (*PSHADOWOFFSET).y});
updateWindow(PWINDOW);
m_vLastWindowPos += WORKSPACEOFFSET;
m_seExtents = {{m_vLastWindowPos.x - fullBox.x - pMonitor->m_position.x + 2, m_vLastWindowPos.y - fullBox.y - pMonitor->m_position.y + 2},
{fullBox.x + fullBox.width + pMonitor->m_position.x - m_vLastWindowPos.x - m_vLastWindowSize.x + 2,
fullBox.y + fullBox.height + pMonitor->m_position.y - m_vLastWindowPos.y - m_vLastWindowSize.y + 2}};
m_lastWindowPos += WORKSPACEOFFSET;
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_lastWindowPos.x - m_lastWindowSize.x + 2,
fullBox.y + fullBox.height + pMonitor->m_position.y - m_lastWindowPos.y - m_lastWindowSize.y + 2}};
fullBox.translate(PWINDOW->m_floatingOffset);
@ -148,18 +148,18 @@ void CHyprDropShadowDecoration::render(PHLMONITOR pMonitor, float const& a) {
return; // don't draw invisible shadows
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
CFramebuffer& alphaFB = g_pHyprOpenGL->m_RenderData.pCurrentMonData->mirrorFB;
CFramebuffer& alphaSwapFB = g_pHyprOpenGL->m_RenderData.pCurrentMonData->mirrorSwapFB;
auto* LASTFB = g_pHyprOpenGL->m_RenderData.currentFB;
CFramebuffer& alphaFB = g_pHyprOpenGL->m_renderData.pCurrentMonData->mirrorFB;
CFramebuffer& alphaSwapFB = g_pHyprOpenGL->m_renderData.pCurrentMonData->mirrorSwapFB;
auto* LASTFB = g_pHyprOpenGL->m_renderData.currentFB;
fullBox.scale(pMonitor->m_scale).round();
if (*PSHADOWIGNOREWINDOW) {
CBox windowBox = m_bLastWindowBox;
CBox withDecos = m_bLastWindowBoxWithDecos;
CBox windowBox = m_lastWindowBox;
CBox withDecos = m_lastWindowBoxWithDecos;
// get window box
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)
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.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.damage = fullBox;
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);
alphaFB.bind();
@ -212,14 +212,14 @@ void CHyprDropShadowDecoration::render(PHLMONITOR pMonitor, float const& a) {
g_pHyprOpenGL->setRenderModifEnabled(true);
g_pHyprOpenGL->setMonitorTransformEnabled(false);
g_pHyprOpenGL->m_RenderData.damage = saveDamage;
g_pHyprOpenGL->m_renderData.damage = saveDamage;
} else
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_pHyprOpenGL->m_RenderData.currentWindow.reset();
g_pHyprOpenGL->m_renderData.currentWindow.reset();
}
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);
private:
SBoxExtents m_seExtents;
SBoxExtents m_seReportedExtents;
SBoxExtents m_extents;
SBoxExtents m_reportedExtents;
PHLWINDOWREF m_pWindow;
PHLWINDOWREF m_window;
Vector2D m_vLastWindowPos;
Vector2D m_vLastWindowSize;
Vector2D m_lastWindowPos;
Vector2D m_lastWindowSize;
void drawShadowInternal(const CBox& box, int round, float roundingPower, int range, CHyprColor color, float a);
CBox m_bLastWindowBox = {0};
CBox m_bLastWindowBoxWithDecos = {0};
CBox m_lastWindowBox = {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;
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 PENABLED = CConfigValue<Hyprlang::INT>("group:groupbar:gradients");
if (m_tGradientActive->m_iTexID == 0 && *PENABLED && *PGRADIENTS)
if (m_tGradientActive->m_texID == 0 && *PENABLED && *PGRADIENTS)
refreshGroupBarGradients();
}
@ -43,7 +43,7 @@ SDecorationPositioningInfo CHyprGroupBarDecoration::getPositioningInfo() {
info.priority = *PPRIORITY;
info.reserved = true;
if (*PENABLED && m_pWindow->m_windowData.decorate.valueOrDefault()) {
if (*PENABLED && m_window->m_windowData.decorate.valueOrDefault()) {
if (*PSTACKED) {
const auto ONEBARHEIGHT = *POUTERGAP + *PINDICATORHEIGHT + *PINDICATORGAP + (*PGRADIENTS || *PRENDERTITLES ? *PHEIGHT : 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) {
m_bAssignedBox = reply.assignedGeometry;
m_assignedBox = reply.assignedGeometry;
}
eDecorationType CHyprGroupBarDecoration::getDecorationType() {
@ -65,8 +65,8 @@ eDecorationType CHyprGroupBarDecoration::getDecorationType() {
//
void CHyprGroupBarDecoration::updateWindow(PHLWINDOW pWindow) {
if (m_pWindow->m_groupData.pNextWindow.expired()) {
m_pWindow->removeWindowDeco(this);
if (m_window->m_groupData.pNextWindow.expired()) {
m_window->removeWindowDeco(this);
return;
}
@ -83,14 +83,14 @@ void CHyprGroupBarDecoration::updateWindow(PHLWINDOW pWindow) {
damageEntire();
if (m_dwGroupMembers.size() == 0) {
m_pWindow->removeWindowDeco(this);
m_window->removeWindowDeco(this);
return;
}
}
void CHyprGroupBarDecoration::damageEntire() {
auto box = assignedBoxGlobal();
box.translate(m_pWindow->m_floatingOffset);
box.translate(m_window->m_floatingOffset);
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");
if (!*PENABLED || !m_pWindow->m_windowData.decorate.valueOrDefault())
if (!*PENABLED || !m_window->m_windowData.decorate.valueOrDefault())
return;
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 ONEBARHEIGHT = *POUTERGAP + *PINDICATORHEIGHT + *PINDICATORGAP + (*PGRADIENTS || *PRENDERTITLES ? *PHEIGHT : 0);
m_fBarWidth = *PSTACKED ? ASSIGNEDBOX.w : (ASSIGNEDBOX.w - *PINNERGAP * (barsToDraw - 1)) / barsToDraw;
m_fBarHeight = *PSTACKED ? ((ASSIGNEDBOX.h - *POUTERGAP * *PKEEPUPPERGAP) - *POUTERGAP * (barsToDraw)) / barsToDraw : ASSIGNEDBOX.h - *POUTERGAP * *PKEEPUPPERGAP;
m_barWidth = *PSTACKED ? ASSIGNEDBOX.w : (ASSIGNEDBOX.w - *PINNERGAP * (barsToDraw - 1)) / barsToDraw;
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;
if (DESIREDHEIGHT != ASSIGNEDBOX.h)
@ -143,13 +143,13 @@ void CHyprGroupBarDecoration::draw(PHLMONITOR pMonitor, float const& a) {
for (int i = 0; i < barsToDraw; ++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,
ASSIGNEDBOX.y + ASSIGNEDBOX.h - floor(yoff) - *PINDICATORHEIGHT - *POUTERGAP - pMonitor->m_position.y + m_pWindow->m_floatingOffset.y, m_fBarWidth,
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_window->m_floatingOffset.y, m_barWidth,
*PINDICATORHEIGHT};
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 PCOLINACTIVE = GROUPLOCKED ? GROUPCOLINACTIVELOCKED : GROUPCOLINACTIVE;
@ -170,25 +170,25 @@ void CHyprGroupBarDecoration::draw(PHLMONITOR pMonitor, float const& a) {
double first = rect.w - (*PROUNDING * 2);
rectdata.round = *PROUNDING;
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.clipBox = CBox{rect.pos() + Vector2D{first, 0.F}, Vector2D{rect.w - first + PADDING, rect.h}};
} else if (i == barsToDraw - 1) {
double first = *PROUNDING * 2;
rectdata.round = 0;
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.clipBox = CBox{rect.pos() + Vector2D{first, 0.F}, Vector2D{rect.w - first + PADDING, rect.h}};
}
} else
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,
ASSIGNEDBOX.y + ASSIGNEDBOX.h - floor(yoff) - ONEBARHEIGHT - pMonitor->m_position.y + m_pWindow->m_floatingOffset.y, m_fBarWidth,
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_window->m_floatingOffset.y, m_barWidth,
(*PGRADIENTS || *PRENDERTITLES ? *PHEIGHT : 0)};
rect.scale(pMonitor->m_scale);
@ -196,7 +196,7 @@ void CHyprGroupBarDecoration::draw(PHLMONITOR pMonitor, float const& a) {
if (*PGRADIENTS) {
const auto GRADIENTTEX = (m_dwGroupMembers[WINDOWINDEX] == g_pCompositor->m_lastWindow ? (GROUPLOCKED ? m_tGradientLockedActive : m_tGradientActive) :
(GROUPLOCKED ? m_tGradientLockedInactive : m_tGradientInactive));
if (GRADIENTTEX->m_iTexID) {
if (GRADIENTTEX->m_texID) {
CTexPassElement::SRenderData data;
data.tex = GRADIENTTEX;
data.box = rect;
@ -210,21 +210,21 @@ void CHyprGroupBarDecoration::draw(PHLMONITOR pMonitor, float const& a) {
double first = rect.w - (*PGRADIENTROUNDING * 2);
data.round = *PGRADIENTROUNDING;
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.clipBox = CBox{rect.pos() + Vector2D{first, 0.F}, Vector2D{rect.w - first + PADDING, rect.h}};
} else if (i == barsToDraw - 1) {
double first = *PGRADIENTROUNDING * 2;
data.round = 0;
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.clipBox = CBox{rect.pos() + Vector2D{first, 0.F}, Vector2D{rect.w - first + PADDING, rect.h}};
}
} else
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);
if (!pTitleTex)
pTitleTex = m_sTitleTexs.titleTexs
pTitleTex = m_titleTexs.titleTexs
.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))
.get();
const auto titleTex = m_dwGroupMembers[WINDOWINDEX] == g_pCompositor->m_lastWindow ? pTitleTex->texActive : pTitleTex->texInactive;
rect.y += std::ceil(((rect.height - titleTex->m_vSize.y) / 2.0) - (*PTEXTOFFSET * pMonitor->m_scale));
rect.height = titleTex->m_vSize.y;
rect.width = titleTex->m_vSize.x;
rect.x += std::round(((m_fBarWidth * pMonitor->m_scale) / 2.0) - (titleTex->m_vSize.x / 2.0));
const auto titleTex = m_dwGroupMembers[WINDOWINDEX] == g_pCompositor->m_lastWindow ? pTitleTex->m_texActive : pTitleTex->m_texInactive;
rect.y += std::ceil(((rect.height - titleTex->m_size.y) / 2.0) - (*PTEXTOFFSET * pMonitor->m_scale));
rect.height = titleTex->m_size.y;
rect.width = titleTex->m_size.x;
rect.x += std::round(((m_barWidth * pMonitor->m_scale) / 2.0) - (titleTex->m_size.x / 2.0));
rect.round();
CTexPassElement::SRenderData data;
data.tex = titleTex;
data.box = rect;
data.a = a;
g_pHyprRenderer->m_sRenderPass.add(makeShared<CTexPassElement>(data));
g_pHyprRenderer->m_renderPass.add(makeShared<CTexPassElement>(data));
}
}
if (*PSTACKED)
yoff += ONEBARHEIGHT;
else
xoff += *PINNERGAP + m_fBarWidth;
xoff += *PINNERGAP + m_barWidth;
}
if (*PRENDERTITLES)
@ -264,8 +264,8 @@ void CHyprGroupBarDecoration::draw(PHLMONITOR pMonitor, float const& a) {
}
CTitleTex* CHyprGroupBarDecoration::textureFromTitle(const std::string& title) {
for (auto const& tex : m_sTitleTexs.titleTexs) {
if (tex->szContent == title)
for (auto const& tex : m_titleTexs.titleTexs) {
if (tex->m_content == title)
return tex.get();
}
@ -273,10 +273,10 @@ CTitleTex* CHyprGroupBarDecoration::textureFromTitle(const std::string& title) {
}
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 PTITLEFONTFAMILY = CConfigValue<std::string>("group:groupbar:font_family");
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 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);
texInactive = g_pHyprOpenGL->renderText(pWindow->m_title, COLOR, *PTITLEFONTSIZE * monitorScale, false, FONTFAMILY, bufferSize.x - 2, FONTWEIGHTINACTIVE->m_value);
m_texActive = g_pHyprOpenGL->renderText(pWindow->m_title, COLOR, *PTITLEFONTSIZE * monitorScale, false, FONTFAMILY, bufferSize.x - 2, FONTWEIGHTACTIVE->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) {
@ -329,7 +329,7 @@ static void renderGradientTo(SP<CTexture> tex, CGradientValueData* grad) {
// copy the data to an OpenGL texture we have
const auto DATA = cairo_image_surface_get_data(CAIROSURFACE);
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_MIN_FILTER, GL_NEAREST);
@ -360,7 +360,7 @@ void refreshGroupBarGradients() {
g_pHyprRenderer->makeEGLCurrent();
if (m_tGradientActive->m_iTexID != 0) {
if (m_tGradientActive->m_texID != 0) {
m_tGradientActive->destroyTexture();
m_tGradientInactive->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 POUTERGAP = CConfigValue<Hyprlang::INT>("group:groupbar:gaps_out");
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;
const float BARRELATIVEX = pos.x - assignedBoxGlobal().x;
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;
if (*PSTACKED && (BARRELATIVEY - (m_fBarHeight + *POUTERGAP) * WINDOWINDEX < *POUTERGAP))
if (*PSTACKED && (BARRELATIVEY - (m_barHeight + *POUTERGAP) * WINDOWINDEX < *POUTERGAP))
return false;
PHLWINDOW pWindow = m_pWindow->getGroupWindowByIndex(WINDOWINDEX);
PHLWINDOW pWindow = m_window->getGroupWindowByIndex(WINDOWINDEX);
// hack
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 POUTERGAP = CConfigValue<Hyprlang::INT>("group:groupbar:gaps_out");
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;
if (!pDraggedWindow->canBeGroupedInto(m_pWindow.lock()) || (*PDRAGINTOGROUP != 1 && *PDRAGINTOGROUP != 2) || (FLOATEDINTOTILED && !*PMERGEFLOATEDINTOTILEDONGROUPBAR) ||
(!*PMERGEGROUPSONGROUPBAR && pDraggedWindow->m_groupData.pNextWindow.lock() && m_pWindow->m_groupData.pNextWindow.lock())) {
if (!pDraggedWindow->canBeGroupedInto(m_window.lock()) || (*PDRAGINTOGROUP != 1 && *PDRAGINTOGROUP != 2) || (FLOATEDINTOTILED && !*PMERGEFLOATEDINTOTILEDONGROUPBAR) ||
(!*PMERGEGROUPSONGROUPBAR && pDraggedWindow->m_groupData.pNextWindow.lock() && m_window->m_groupData.pNextWindow.lock())) {
g_pInputManager->m_wasDraggingWindow = true;
return false;
}
const float BARRELATIVE = *PSTACKED ? pos.y - assignedBoxGlobal().y - (m_fBarHeight + *POUTERGAP) / 2 : pos.x - assignedBoxGlobal().x - m_fBarWidth / 2;
const float BARSIZE = *PSTACKED ? m_fBarHeight + *POUTERGAP : m_fBarWidth + *PINNERGAP;
const float BARRELATIVE = *PSTACKED ? pos.y - assignedBoxGlobal().y - (m_barHeight + *POUTERGAP) / 2 : pos.x - assignedBoxGlobal().x - m_barWidth / 2;
const float BARSIZE = *PSTACKED ? m_barHeight + *POUTERGAP : m_barWidth + *PINNERGAP;
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 pDraggedHead = pDraggedWindow->m_groupData.pNextWindow.lock() ? pDraggedWindow->getGroupHead() : pDraggedWindow;
@ -478,7 +478,7 @@ bool CHyprGroupBarDecoration::onEndWindowDragOnDeco(const Vector2D& pos, PHLWIND
if (WINDOWINDEX == -1)
std::swap(pDraggedHead->m_groupData.head, pWindowInsertEnd->m_groupData.head);
m_pWindow->setGroupCurrent(pDraggedWindow);
m_window->setGroupCurrent(pDraggedWindow);
pDraggedWindow->applyGroupRules();
pDraggedWindow->updateWindowDecos();
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 POUTERGAP = CConfigValue<Hyprlang::INT>("group:groupbar:gaps_out");
static auto PINNERGAP = CConfigValue<Hyprlang::INT>("group:groupbar:gaps_in");
if (m_pWindow->isEffectiveInternalFSMode(FSMODE_FULLSCREEN))
if (m_window->isEffectiveInternalFSMode(FSMODE_FULLSCREEN))
return true;
const float BARRELATIVEX = pos.x - assignedBoxGlobal().x;
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");
// 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)
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;
}
@ -517,17 +517,17 @@ bool CHyprGroupBarDecoration::onMouseButtonOnDeco(const Vector2D& pos, const IPo
return true;
// click on padding
const auto TABPAD = !*PSTACKED && (BARRELATIVEX - (m_fBarWidth + *PINNERGAP) * WINDOWINDEX > m_fBarWidth);
const auto STACKPAD = *PSTACKED && (BARRELATIVEY - (m_fBarHeight + *POUTERGAP) * WINDOWINDEX < *POUTERGAP);
const auto TABPAD = !*PSTACKED && (BARRELATIVEX - (m_barWidth + *PINNERGAP) * WINDOWINDEX > m_barWidth);
const auto STACKPAD = *PSTACKED && (BARRELATIVEY - (m_barHeight + *POUTERGAP) * WINDOWINDEX < *POUTERGAP);
if (TABPAD || STACKPAD) {
if (!g_pCompositor->isWindowActive(m_pWindow.lock()))
g_pCompositor->focusWindow(m_pWindow.lock());
if (!g_pCompositor->isWindowActive(m_window.lock()))
g_pCompositor->focusWindow(m_window.lock());
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);
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) {
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;
if (e.delta > 0)
m_pWindow->setGroupCurrent(m_pWindow->m_groupData.pNextWindow.lock());
m_window->setGroupCurrent(m_window->m_groupData.pNextWindow.lock());
else
m_pWindow->setGroupCurrent(m_pWindow->getGroupPrevious());
m_window->setGroupCurrent(m_window->getGroupPrevious());
return true;
}
@ -576,12 +576,12 @@ std::string CHyprGroupBarDecoration::getDisplayName() {
}
CBox CHyprGroupBarDecoration::assignedBoxGlobal() {
CBox box = m_bAssignedBox;
box.translate(g_pDecorationPositioner->getEdgeDefinedPoint(DECORATION_EDGE_TOP, m_pWindow.lock()));
CBox box = m_assignedBox;
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());
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() = default;
SP<CTexture> texActive;
SP<CTexture> texInactive;
std::string szContent;
SP<CTexture> m_texActive;
SP<CTexture> m_texInactive;
std::string m_content;
PHLWINDOWREF pWindowOwner;
PHLWINDOWREF m_windowOwner;
};
void refreshGroupBarGradients();
@ -47,16 +47,14 @@ class CHyprGroupBarDecoration : public IHyprWindowDecoration {
virtual std::string getDisplayName();
private:
SBoxExtents m_seExtents;
CBox m_assignedBox = {0};
CBox m_bAssignedBox = {0};
PHLWINDOWREF m_pWindow;
PHLWINDOWREF m_window;
std::vector<PHLWINDOWREF> m_dwGroupMembers;
float m_fBarWidth;
float m_fBarHeight;
float m_barWidth;
float m_barHeight;
CTitleTex* textureFromTitle(const std::string&);
void invalidateTextures();
@ -71,5 +69,5 @@ class CHyprGroupBarDecoration : public IHyprWindowDecoration {
struct STitleTexs {
// STitleTexs* overriden = nullptr; // TODO: make shit shared in-group to decrease VRAM usage.
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) {
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(); });
if (WIT == m_mWindowDatas.end())
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_windowDatas.end())
return;
WIT->second.needsRecalc = true;
@ -70,16 +70,16 @@ void CDecorationPositioner::uncacheDecoration(IHyprWindowDecoration* deco) {
void CDecorationPositioner::repositionDeco(IHyprWindowDecoration* deco) {
uncacheDecoration(deco);
onWindowUpdate(deco->m_pWindow.lock());
onWindowUpdate(deco->m_window.lock());
}
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();
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();
@ -87,8 +87,8 @@ CDecorationPositioner::SWindowPositioningData* CDecorationPositioner::getDataFor
}
void CDecorationPositioner::sanitizeDatas() {
std::erase_if(m_mWindowDatas, [](const auto& other) { return !valid(other.first); });
std::erase_if(m_vWindowPositioningDatas, [](const auto& other) {
std::erase_if(m_windowDatas, [](const auto& other) { return !valid(other.first); });
std::erase_if(m_windowPositioningDatas, [](const auto& other) {
if (!validMapped(other->pWindow))
return true;
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) {
const auto WIT = std::find_if(m_mWindowDatas.begin(), m_mWindowDatas.end(), [&](const auto& other) { return other.first.lock() == pWindow; });
if (WIT == m_mWindowDatas.end())
const auto WIT = std::find_if(m_windowDatas.begin(), m_windowDatas.end(), [&](const auto& other) { return other.first.lock() == pWindow; });
if (WIT == m_windowDatas.end())
return;
const auto WINDOWDATA = &WIT->second;
@ -112,8 +112,8 @@ void CDecorationPositioner::onWindowUpdate(PHLWINDOW pWindow) {
if (!validMapped(pWindow))
return;
const auto WIT = std::find_if(m_mWindowDatas.begin(), m_mWindowDatas.end(), [&](const auto& other) { return other.first.lock() == pWindow; });
if (WIT == m_mWindowDatas.end())
const auto WIT = std::find_if(m_windowDatas.begin(), m_windowDatas.end(), [&](const auto& other) { return other.first.lock() == pWindow; });
if (WIT == m_windowDatas.end())
return;
const auto WINDOWDATA = &WIT->second;
@ -130,7 +130,7 @@ void CDecorationPositioner::onWindowUpdate(PHLWINDOW pWindow) {
}
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; })
/* all window datas are either not for this window or don't need a reposition */
&& !WINDOWDATA->needsRecalc /* window doesn't need recalc */
@ -282,17 +282,17 @@ void CDecorationPositioner::onWindowUpdate(PHLWINDOW pWindow) {
}
void CDecorationPositioner::onWindowUnmap(PHLWINDOW pWindow) {
std::erase_if(m_vWindowPositioningDatas, [&](const auto& data) { return data->pWindow.lock() == pWindow; });
m_mWindowDatas.erase(pWindow);
std::erase_if(m_windowPositioningDatas, [&](const auto& data) { return data->pWindow.lock() == pWindow; });
m_windowDatas.erase(pWindow);
}
void CDecorationPositioner::onWindowMap(PHLWINDOW pWindow) {
m_mWindowDatas[pWindow] = {};
m_windowDatas[pWindow] = {};
}
SBoxExtents CDecorationPositioner::getWindowDecorationReserved(PHLWINDOW pWindow) {
try {
const auto E = m_mWindowDatas.at(pWindow);
const auto E = m_windowDatas.at(pWindow);
return E.reserved;
} catch (std::out_of_range& e) { return {}; }
}
@ -301,7 +301,7 @@ SBoxExtents CDecorationPositioner::getWindowDecorationExtents(PHLWINDOW pWindow,
CBox const mainSurfaceBox = pWindow->getWindowMainSurfaceBox();
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)))
continue;
@ -349,7 +349,7 @@ SBoxExtents CDecorationPositioner::getWindowDecorationExtents(PHLWINDOW pWindow,
CBox CDecorationPositioner::getBoxWithIncludedDecos(PHLWINDOW pWindow) {
CBox accum = pWindow->getWindowMainSurfaceBox();
for (auto const& data : m_vWindowPositioningDatas) {
for (auto const& data : m_windowPositioningDatas) {
if (data->pWindow.lock() != pWindow)
continue;
@ -385,7 +385,7 @@ CBox CDecorationPositioner::getBoxWithIncludedDecos(PHLWINDOW pWindow) {
}
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);
CBox box = DATA->lastReply.assignedGeometry;

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

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

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

@ -2,7 +2,7 @@
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();
private:
PHLWINDOWREF m_pWindow;
PHLWINDOWREF m_window;
friend class CDecorationPositioner;
};

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

@ -1,15 +1,15 @@
#include "BorderPassElement.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) {
if (data.hasGrad2)
g_pHyprOpenGL->renderBorder(data.box, data.grad1, data.grad2, data.lerp, data.round, data.roundingPower, data.borderSize, data.a, data.outerRound);
if (m_data.hasGrad2)
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
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() {

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

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

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

@ -1,12 +1,12 @@
#include "ClearPassElement.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) {
g_pHyprOpenGL->clear(data.color);
g_pHyprOpenGL->clear(m_data.color);
}
bool CClearPassElement::needsLiveBlur() {

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

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

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

@ -1,18 +1,18 @@
#include "FramebufferElement.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) {
CFramebuffer* fb = nullptr;
if (data.main) {
switch (data.framebufferID) {
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_OUT: fb = g_pHyprOpenGL->m_RenderData.outFB; break;
if (m_data.main) {
switch (m_data.framebufferID) {
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_OUT: fb = g_pHyprOpenGL->m_renderData.outFB; break;
}
if (!fb) {
@ -21,13 +21,13 @@ void CFramebufferElement::draw(const CRegion& damage) {
}
} else {
switch (data.framebufferID) {
case FB_MONITOR_RENDER_EXTRA_OFFLOAD: fb = &g_pHyprOpenGL->m_RenderData.pCurrentMonData->offloadFB; break;
case FB_MONITOR_RENDER_EXTRA_MIRROR: fb = &g_pHyprOpenGL->m_RenderData.pCurrentMonData->mirrorFB; break;
case FB_MONITOR_RENDER_EXTRA_MIRROR_SWAP: fb = &g_pHyprOpenGL->m_RenderData.pCurrentMonData->mirrorSwapFB; break;
case FB_MONITOR_RENDER_EXTRA_OFF_MAIN: fb = &g_pHyprOpenGL->m_RenderData.pCurrentMonData->offMainFB; break;
case FB_MONITOR_RENDER_EXTRA_MONITOR_MIRROR: fb = &g_pHyprOpenGL->m_RenderData.pCurrentMonData->monitorMirrorFB; break;
case FB_MONITOR_RENDER_EXTRA_BLUR: fb = &g_pHyprOpenGL->m_RenderData.pCurrentMonData->blurFB; break;
switch (m_data.framebufferID) {
case FB_MONITOR_RENDER_EXTRA_OFFLOAD: fb = &g_pHyprOpenGL->m_renderData.pCurrentMonData->offloadFB; break;
case FB_MONITOR_RENDER_EXTRA_MIRROR: fb = &g_pHyprOpenGL->m_renderData.pCurrentMonData->mirrorFB; break;
case FB_MONITOR_RENDER_EXTRA_MIRROR_SWAP: fb = &g_pHyprOpenGL->m_renderData.pCurrentMonData->mirrorSwapFB; break;
case FB_MONITOR_RENDER_EXTRA_OFF_MAIN: fb = &g_pHyprOpenGL->m_renderData.pCurrentMonData->offMainFB; break;
case FB_MONITOR_RENDER_EXTRA_MONITOR_MIRROR: fb = &g_pHyprOpenGL->m_renderData.pCurrentMonData->monitorMirrorFB; break;
case FB_MONITOR_RENDER_EXTRA_BLUR: fb = &g_pHyprOpenGL->m_renderData.pCurrentMonData->blurFB; break;
}
if (!fb) {

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

@ -21,5 +21,5 @@ class CFramebufferElement : public IPassElement {
}
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 {
return m_vPassElements.size() == 1;
return m_passElements.size() == 1;
}
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() {
@ -28,10 +28,10 @@ void CRenderPass::simplify() {
// 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
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});
for (auto& el : m_vPassElements | std::views::reverse) {
CRegion newDamage = m_damage.copy().intersect(CBox{{}, g_pHyprOpenGL->m_renderData.pMonitor->m_transformedSize});
for (auto& el : m_passElements | std::views::reverse) {
if (newDamage.empty() && !el->element->undiscardable()) {
el->discard = true;
@ -43,7 +43,7 @@ void CRenderPass::simplify() {
if (!bb1 || newDamage.empty())
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
if (CRegion copy = newDamage.copy(); copy.intersect(bb).empty()) {
@ -54,13 +54,13 @@ void CRenderPass::simplify() {
auto opaque = el->element->opaqueRegion();
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.
// do not occlude a border near it.
if (WILLBLUR) {
CRegion liveBlurRegion;
for (auto& el2 : m_vPassElements) {
for (auto& el2 : m_passElements) {
// if we reach self, no problem, we can break.
// if the blur is above us, we don't care, it will work fine.
if (el2 == el)
@ -76,7 +76,7 @@ void CRenderPass::simplify() {
}
// 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()) {
// eh, this is not the correct solution, but it will do...
@ -86,57 +86,57 @@ void CRenderPass::simplify() {
}
newDamage.subtract(opaque);
if (*PDEBUGPASS)
occludedRegions.emplace_back(opaque);
m_occludedRegions.emplace_back(opaque);
}
}
if (*PDEBUGPASS) {
for (auto& el2 : m_vPassElements) {
for (auto& el2 : m_passElements) {
if (!el2->element->needsLiveBlur())
continue;
const auto BB = el2->element->boundingBox();
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() {
m_vPassElements.clear();
m_passElements.clear();
}
CRegion CRenderPass::render(const CRegion& damage_) {
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) {
occludedRegions.clear();
totalLiveBlurRegion = CRegion{};
m_occludedRegions.clear();
m_totalLiveBlurRegion = CRegion{};
}
if (damage.empty()) {
g_pHyprOpenGL->m_RenderData.damage = damage;
g_pHyprOpenGL->m_RenderData.finalDamage = damage;
return damage;
if (m_damage.empty()) {
g_pHyprOpenGL->m_renderData.damage = m_damage;
g_pHyprOpenGL->m_renderData.finalDamage = m_damage;
return m_damage;
}
if (!*PDEBUGPASS && debugData.present)
debugData = {false};
else if (*PDEBUGPASS && !debugData.present) {
debugData.present = true;
debugData.keyboardFocusText = g_pHyprOpenGL->renderText("keyboard", Colors::WHITE, 12);
debugData.pointerFocusText = g_pHyprOpenGL->renderText("pointer", Colors::WHITE, 12);
debugData.lastWindowText = g_pHyprOpenGL->renderText("lastWindow", Colors::WHITE, 12);
if (!*PDEBUGPASS && m_debugData.present)
m_debugData = {false};
else if (*PDEBUGPASS && !m_debugData.present) {
m_debugData.present = true;
m_debugData.keyboardFocusText = g_pHyprOpenGL->renderText("keyboard", Colors::WHITE, 12);
m_debugData.pointerFocusText = g_pHyprOpenGL->renderText("pointer", Colors::WHITE, 12);
m_debugData.lastWindowText = g_pHyprOpenGL->renderText("lastWindow", Colors::WHITE, 12);
}
if (WILLBLUR && !*PDEBUGPASS) {
// combine blur regions into one that will be expanded
CRegion blurRegion;
for (auto& el : m_vPassElements) {
for (auto& el : m_passElements) {
if (!el->element->needsLiveBlur())
continue;
@ -146,40 +146,40 @@ CRegion CRenderPass::render(const CRegion& damage_) {
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 ?
// used to work when we expand all the damage... I think? Well, before pass.
// moving a window over blur shows the edges being wonk.
blurRegion.expand(oneBlurRadius() * 1.5F);
damage = blurRegion.copy().add(damage);
m_damage = blurRegion.copy().add(m_damage);
} 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(); })) {
for (auto& el : m_vPassElements) {
el->elementDamage = damage;
if (std::ranges::any_of(m_passElements, [](const auto& el) { return el->element->disableSimplification(); })) {
for (auto& el : m_passElements) {
el->elementDamage = m_damage;
}
} else
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 {};
for (auto& el : m_vPassElements) {
for (auto& el : m_passElements) {
if (el->discard) {
el->element->discard();
continue;
}
g_pHyprOpenGL->m_RenderData.damage = el->elementDamage;
g_pHyprOpenGL->m_renderData.damage = el->elementDamage;
el->element->draw(el->elementDamage);
}
@ -192,16 +192,16 @@ CRegion CRenderPass::render(const CRegion& damage_) {
});
}
g_pHyprOpenGL->m_RenderData.damage = damage;
return damage;
g_pHyprOpenGL->m_renderData.damage = m_damage;
return m_damage;
}
void CRenderPass::renderDebugData() {
CBox box = {{}, g_pHyprOpenGL->m_RenderData.pMonitor->m_transformedSize};
for (const auto& rg : occludedRegions) {
CBox box = {{}, g_pHyprOpenGL->m_renderData.pMonitor->m_transformedSize};
for (const auto& rg : m_occludedRegions) {
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;
@ -219,9 +219,9 @@ void CRenderPass::renderDebugData() {
if (!bb.has_value())
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;
g_pHyprOpenGL->renderRectWithDamage(box, color, CRegion{0, 0, INT32_MAX, INT32_MAX});
@ -231,17 +231,17 @@ void CRenderPass::renderDebugData() {
else
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->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(debugData.pointerFocusText, g_pSeatManager->m_state.pointerFocus.lock(), Colors::ORANGE.modifyA(0.1F));
renderHLSurface(m_debugData.keyboardFocusText, g_pSeatManager->m_state.keyboardFocus.lock(), Colors::PURPLE.modifyA(0.1F));
renderHLSurface(m_debugData.pointerFocusText, g_pSeatManager->m_state.pointerFocus.lock(), Colors::ORANGE.modifyA(0.1F));
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->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();
if (BOX) {
auto region = g_pSeatManager->m_state.pointerFocus->m_current.input.copy()
.scale(g_pHyprOpenGL->m_RenderData.pMonitor->m_scale)
.translate(BOX->pos() - g_pHyprOpenGL->m_RenderData.pMonitor->m_position);
.scale(g_pHyprOpenGL->m_renderData.pMonitor->m_scale)
.translate(BOX->pos() - g_pHyprOpenGL->m_renderData.pMonitor->m_position);
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; });
auto tex = g_pHyprOpenGL->renderText(std::format("occlusion layers: {}\npass elements: {} ({} discarded)\nviewport: {:X0}", occludedRegions.size(), m_vPassElements.size(),
DISCARDED_ELEMENTS, g_pHyprOpenGL->m_RenderData.pMonitor->m_pixelSize),
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}", m_occludedRegions.size(), m_passElements.size(),
DISCARDED_ELEMENTS, g_pHyprOpenGL->m_renderData.pMonitor->m_pixelSize),
Colors::WHITE, 12);
if (tex) {
box = CBox{{0.F, g_pHyprOpenGL->m_RenderData.pMonitor->m_size.y - tex->m_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);
}
std::string passStructure;
auto yn = [](const bool val) -> const char* { return val ? "yes" : "no"; };
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()),
yn(!el->element->opaqueRegion().empty()));
}
@ -282,8 +282,8 @@ void CRenderPass::renderDebugData() {
tex = g_pHyprOpenGL->renderText(passStructure, Colors::WHITE, 12);
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(
g_pHyprOpenGL->m_RenderData.pMonitor->m_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->renderTexture(tex, box, 1.F);
}
}
@ -296,5 +296,5 @@ float CRenderPass::oneBlurRadius() {
}
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_);
private:
CRegion damage;
std::vector<CRegion> occludedRegions;
CRegion totalLiveBlurRegion;
CRegion m_damage;
std::vector<CRegion> m_occludedRegions;
CRegion m_totalLiveBlurRegion;
struct SPassElementData {
CRegion elementDamage;
@ -28,9 +28,7 @@ class CRenderPass {
bool discard = false;
};
std::vector<SP<SPassElementData>> m_vPassElements;
SP<IPassElement> currentPassInfo = nullptr;
std::vector<SP<SPassElementData>> m_passElements;
void simplify();
float oneBlurRadius();
@ -39,7 +37,7 @@ class CRenderPass {
struct {
bool present = false;
SP<CTexture> keyboardFocusText, pointerFocusText, lastWindowText;
} debugData;
} m_debugData;
friend class CHyprOpenGLImpl;
};

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

@ -1,45 +1,45 @@
#include "RectPassElement.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) {
if (data.box.w <= 0 || data.box.h <= 0)
if (m_data.box.w <= 0 || m_data.box.h <= 0)
return;
if (!data.clipBox.empty())
g_pHyprOpenGL->m_RenderData.clipBox = data.clipBox;
if (!m_data.clipBox.empty())
g_pHyprOpenGL->m_renderData.clipBox = m_data.clipBox;
if (data.color.a == 1.F || !data.blur)
g_pHyprOpenGL->renderRectWithDamage(data.box, data.color, damage, data.round, data.roundingPower);
if (m_data.color.a == 1.F || !m_data.blur)
g_pHyprOpenGL->renderRectWithDamage(m_data.box, m_data.color, damage, m_data.round, m_data.roundingPower);
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() {
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() {
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() {
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() {
if (data.color.a < 1.F)
if (m_data.color.a < 1.F)
return CRegion{};
CRegion rg = boundingBox()->expand(-data.round);
CRegion rg = boundingBox()->expand(-m_data.round);
if (!data.clipBox.empty())
rg.intersect(data.clipBox);
if (!m_data.clipBox.empty())
rg.intersect(m_data.clipBox);
return rg;
}

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

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

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

@ -1,13 +1,13 @@
#include "RendererHintsPassElement.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) {
if (data.renderModif.has_value())
g_pHyprOpenGL->m_RenderData.renderModif = *data.renderModif;
if (m_data.renderModif.has_value())
g_pHyprOpenGL->m_renderData.renderModif = *m_data.renderModif;
}
bool CRendererHintsPassElement::needsLiveBlur() {

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

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

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

@ -2,12 +2,12 @@
#include "../OpenGL.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) {
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() {

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

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

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

@ -12,59 +12,59 @@
#include <hyprutils/utils/ScopeGuard.hpp>
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) {
g_pHyprOpenGL->m_RenderData.currentWindow = data.pWindow;
g_pHyprOpenGL->m_RenderData.surface = data.surface;
g_pHyprOpenGL->m_RenderData.currentLS = data.pLS;
g_pHyprOpenGL->m_RenderData.clipBox = data.clipBox;
g_pHyprOpenGL->m_RenderData.discardMode = data.discardMode;
g_pHyprOpenGL->m_RenderData.discardOpacity = data.discardOpacity;
g_pHyprOpenGL->m_RenderData.useNearestNeighbor = data.useNearestNeighbor;
g_pHyprOpenGL->m_bEndFrame = data.flipEndFrame;
g_pHyprOpenGL->m_renderData.currentWindow = m_data.pWindow;
g_pHyprOpenGL->m_renderData.surface = m_data.surface;
g_pHyprOpenGL->m_renderData.currentLS = m_data.pLS;
g_pHyprOpenGL->m_renderData.clipBox = m_data.clipBox;
g_pHyprOpenGL->m_renderData.discardMode = m_data.discardMode;
g_pHyprOpenGL->m_renderData.discardOpacity = m_data.discardOpacity;
g_pHyprOpenGL->m_renderData.useNearestNeighbor = m_data.useNearestNeighbor;
g_pHyprOpenGL->m_endFrame = m_data.flipEndFrame;
CScopeGuard x = {[]() {
g_pHyprOpenGL->m_RenderData.primarySurfaceUVTopLeft = Vector2D(-1, -1);
g_pHyprOpenGL->m_RenderData.primarySurfaceUVBottomRight = Vector2D(-1, -1);
g_pHyprOpenGL->m_RenderData.useNearestNeighbor = false;
g_pHyprOpenGL->m_RenderData.clipBox = {};
g_pHyprOpenGL->m_RenderData.clipRegion = {};
g_pHyprOpenGL->m_RenderData.discardMode = 0;
g_pHyprOpenGL->m_RenderData.discardOpacity = 0;
g_pHyprOpenGL->m_RenderData.useNearestNeighbor = false;
g_pHyprOpenGL->m_bEndFrame = false;
g_pHyprOpenGL->m_RenderData.currentWindow.reset();
g_pHyprOpenGL->m_RenderData.surface.reset();
g_pHyprOpenGL->m_RenderData.currentLS.reset();
g_pHyprOpenGL->m_renderData.primarySurfaceUVTopLeft = Vector2D(-1, -1);
g_pHyprOpenGL->m_renderData.primarySurfaceUVBottomRight = Vector2D(-1, -1);
g_pHyprOpenGL->m_renderData.useNearestNeighbor = false;
g_pHyprOpenGL->m_renderData.clipBox = {};
g_pHyprOpenGL->m_renderData.clipRegion = {};
g_pHyprOpenGL->m_renderData.discardMode = 0;
g_pHyprOpenGL->m_renderData.discardOpacity = 0;
g_pHyprOpenGL->m_renderData.useNearestNeighbor = false;
g_pHyprOpenGL->m_endFrame = false;
g_pHyprOpenGL->m_renderData.currentWindow.reset();
g_pHyprOpenGL->m_renderData.surface.reset();
g_pHyprOpenGL->m_renderData.currentLS.reset();
}};
if (!data.texture)
if (!m_data.texture)
return;
const auto& TEXTURE = data.texture;
const auto& TEXTURE = m_data.texture;
// this is bad, probably has been logged elsewhere. Means the texture failed
// uploading to the GPU.
if (!TEXTURE->m_iTexID)
if (!TEXTURE->m_texID)
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");
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 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();
const auto PROJSIZEUNSCALED = windowBox.size();
windowBox.scale(data.pMonitor->m_scale);
windowBox.scale(m_data.pMonitor->m_scale);
windowBox.round();
if (windowBox.width <= 1 || windowBox.height <= 1) {
@ -72,17 +72,17 @@ void CSurfacePassElement::draw(const CRegion& damage) {
return;
}
const bool MISALIGNEDFSV1 = std::floor(data.pMonitor->m_scale) != data.pMonitor->m_scale /* Fractional */ && 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) &&
DELTALESSTHAN(windowBox.height, 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 */;
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() != m_data.surface->m_current.bufferSize /* misaligned */ && DELTALESSTHAN(windowBox.width, m_data.surface->m_current.bufferSize.x, 3) &&
DELTALESSTHAN(windowBox.height, m_data.surface->m_current.bufferSize.y, 3) /* off by one-or-two */ &&
(!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");
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;
g_pHyprOpenGL->m_RenderData.clipRegion = visibleRegion(cancelRender);
g_pHyprOpenGL->m_renderData.clipRegion = visibleRegion(cancelRender);
if (cancelRender)
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.
// UV will fixup it as well
if (MISALIGNEDFSV1)
g_pHyprOpenGL->m_RenderData.useNearestNeighbor = true;
g_pHyprOpenGL->m_renderData.useNearestNeighbor = true;
float rounding = data.rounding;
float roundingPower = data.roundingPower;
float rounding = m_data.rounding;
float roundingPower = m_data.roundingPower;
rounding -= 1; // to fix a border issue
if (data.dontRound) {
if (m_data.dontRound) {
rounding = 0;
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;
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
// 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)
if (data.surfaceCounter == 0 && !data.popup) {
if (m_data.surfaceCounter == 0 && !m_data.popup) {
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
g_pHyprOpenGL->renderTexture(TEXTURE, windowBox, ALPHA * OVERALL_ALPHA, rounding, roundingPower, false, true);
} else {
if (BLUR && data.popup)
g_pHyprOpenGL->renderTextureWithBlur(TEXTURE, windowBox, ALPHA, data.surface, rounding, roundingPower, true, data.fadeAlpha, OVERALL_ALPHA);
if (BLUR && m_data.popup)
g_pHyprOpenGL->renderTextureWithBlur(TEXTURE, windowBox, ALPHA, m_data.surface, rounding, roundingPower, true, m_data.fadeAlpha, OVERALL_ALPHA);
else
g_pHyprOpenGL->renderTexture(TEXTURE, windowBox, ALPHA * OVERALL_ALPHA, rounding, roundingPower, false, true);
}
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
// 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())
g_pHyprRenderer->usedAsyncBuffers.emplace_back(data.surface->m_current.buffer);
if (m_data.surface->m_current.buffer && !m_data.surface->m_current.buffer->isSynchronous())
g_pHyprRenderer->m_usedAsyncBuffers.emplace_back(m_data.surface->m_current.buffer);
g_pHyprOpenGL->blend(true);
}
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;
auto PSURFACE = CWLSurface::fromResource(data.surface);
const auto INTERACTIVERESIZEINPROGRESS = m_data.pWindow && g_pInputManager->m_currentlyDraggedWindow && g_pInputManager->m_dragMode == MBIND_RESIZE;
auto PSURFACE = CWLSurface::fromResource(m_data.surface);
CBox windowBox;
if (data.surface && data.mainSurface) {
windowBox = {(int)outputX + data.pos.x + data.localPos.x, (int)outputY + data.pos.y + data.localPos.y, data.w, data.h};
if (m_data.surface && m_data.mainSurface) {
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
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
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),
std::max((float)data.surface->m_current.size.y, 2.F)};
if (data.pWindow && data.pWindow->m_realSize->isBeingAnimated() && data.surface && !data.mainSurface && data.squishOversized /* subsurface */) {
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)m_data.surface->m_current.size.y, 2.F)};
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
windowBox.width = (windowBox.width / data.pWindow->m_reportedSize.x) * data.pWindow->m_realSize->value().x;
windowBox.height = (windowBox.height / data.pWindow->m_reportedSize.y) * data.pWindow->m_realSize->value().y;
windowBox.width = (windowBox.width / m_data.pWindow->m_reportedSize.x) * m_data.pWindow->m_realSize->value().x;
windowBox.height = (windowBox.height / m_data.pWindow->m_reportedSize.y) * m_data.pWindow->m_realSize->value().y;
}
}
if (data.squishOversized) {
if (data.localPos.x + windowBox.width > data.w)
windowBox.width = data.w - data.localPos.x;
if (data.localPos.y + windowBox.height > data.h)
windowBox.height = data.h - data.localPos.y;
if (m_data.squishOversized) {
if (m_data.localPos.x + windowBox.width > m_data.w)
windowBox.width = m_data.w - m_data.localPos.x;
if (m_data.localPos.y + windowBox.height > m_data.h)
windowBox.height = m_data.h - m_data.localPos.y;
}
return windowBox;
}
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 bool BLUR = data.blur && (!data.texture || !data.texture->m_bOpaque || ALPHA < 1.F);
const float ALPHA = m_data.alpha * m_data.fadeAlpha * (PSURFACE ? PSURFACE->m_alphaModifier * PSURFACE->m_overallOpacity : 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;
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;
}
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 bool BLUR = data.blur && (!data.texture || !data.texture->m_bOpaque || ALPHA < 1.F);
const float ALPHA = m_data.alpha * m_data.fadeAlpha * (PSURFACE ? PSURFACE->m_alphaModifier * PSURFACE->m_overallOpacity : 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;
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;
}
@ -219,29 +219,29 @@ std::optional<CBox> CSurfacePassElement::boundingBox() {
}
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)
return {};
if (data.surface && data.surface->m_current.size == Vector2D{data.w, data.h}) {
CRegion opaqueSurf = data.surface->m_current.opaque.copy().intersect(CBox{{}, {data.w, data.h}});
if (m_data.surface && m_data.surface->m_current.size == Vector2D{m_data.w, m_data.h}) {
CRegion opaqueSurf = m_data.surface->m_current.opaque.copy().intersect(CBox{{}, {m_data.w, m_data.h}});
const auto texBox = getTexBox();
opaqueSurf.scale(texBox.size() / Vector2D{data.w, data.h});
return opaqueSurf.translate(data.pos + data.localPos - data.pMonitor->m_position).expand(-data.rounding);
opaqueSurf.scale(texBox.size() / Vector2D{m_data.w, m_data.h});
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) {
auto PSURFACE = CWLSurface::fromResource(data.surface);
auto PSURFACE = CWLSurface::fromResource(m_data.surface);
if (!PSURFACE)
return {};
const auto& bufferSize = data.surface->m_current.bufferSize;
const auto& bufferSize = m_data.surface->m_current.bufferSize;
auto visibleRegion = PSURFACE->m_visibleRegion.copy();
if (visibleRegion.empty())
@ -257,8 +257,8 @@ CRegion CSurfacePassElement::visibleRegion(bool& cancel) {
// deal with any rounding errors that might come from scaling
visibleRegion.expand(1);
auto uvTL = g_pHyprOpenGL->m_RenderData.primarySurfaceUVTopLeft;
auto uvBR = g_pHyprOpenGL->m_RenderData.primarySurfaceUVBottomRight;
auto uvTL = g_pHyprOpenGL->m_renderData.primarySurfaceUVTopLeft;
auto uvBR = g_pHyprOpenGL->m_renderData.primarySurfaceUVBottomRight;
if (uvTL == Vector2D(-1, -1))
uvTL = Vector2D(0, 0);
@ -269,11 +269,11 @@ CRegion CSurfacePassElement::visibleRegion(bool& cancel) {
visibleRegion.translate(-uvTL * bufferSize);
auto texBox = getTexBox();
texBox.scale(data.pMonitor->m_scale);
texBox.scale(m_data.pMonitor->m_scale);
texBox.round();
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;
}
@ -281,6 +281,6 @@ CRegion CSurfacePassElement::visibleRegion(bool& cancel) {
void CSurfacePassElement::discard() {
if (!g_pHyprRenderer->m_bBlockSurfaceFeedback) {
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:
SRenderData data;
SRenderData m_data;
CBox getTexBox();
};

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

@ -4,27 +4,27 @@
#include <hyprutils/utils/ScopeGuard.hpp>
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) {
g_pHyprOpenGL->m_bEndFrame = data.flipEndFrame;
g_pHyprOpenGL->m_endFrame = m_data.flipEndFrame;
CScopeGuard x = {[]() {
//
g_pHyprOpenGL->m_bEndFrame = false;
g_pHyprOpenGL->m_RenderData.clipBox = {};
g_pHyprOpenGL->m_endFrame = false;
g_pHyprOpenGL->m_renderData.clipBox = {};
}};
if (!data.clipBox.empty())
g_pHyprOpenGL->m_RenderData.clipBox = data.clipBox;
if (!m_data.clipBox.empty())
g_pHyprOpenGL->m_renderData.clipBox = m_data.clipBox;
if (data.replaceProjection)
g_pHyprOpenGL->m_RenderData.monitorProjection = *data.replaceProjection;
g_pHyprOpenGL->renderTextureInternalWithDamage(data.tex, data.box, data.a, data.damage.empty() ? damage : data.damage, data.round, data.roundingPower);
if (data.replaceProjection)
g_pHyprOpenGL->m_RenderData.monitorProjection = g_pHyprOpenGL->m_RenderData.pMonitor->m_projMatrix;
if (m_data.replaceProjection)
g_pHyprOpenGL->m_renderData.monitorProjection = *m_data.replaceProjection;
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 (m_data.replaceProjection)
g_pHyprOpenGL->m_renderData.monitorProjection = g_pHyprOpenGL->m_renderData.pMonitor->m_projMatrix;
}
bool CTexPassElement::needsLiveBlur() {
@ -36,7 +36,7 @@ bool CTexPassElement::needsPrecomputeBlur() {
}
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() {

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

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

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

@ -1,19 +1,19 @@
#include "TextureMatteElement.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) {
if (data.disableTransformAndModify) {
if (m_data.disableTransformAndModify) {
g_pHyprOpenGL->setMonitorTransformEnabled(true);
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->setMonitorTransformEnabled(false);
} 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() {

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

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