yukijoou/kwin
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions
kwin/src/surfaceitem.cpp

199 lines
4 KiB
C++
Raw Normal View History

scene: Introduce window items Currently, dealing with sub-surfaces is very difficult due to the scene design being heavily influenced by X11 requirements. The goal of this change is to re-work scene abstractions to make improving the wayland support easier. The Item class is based on the QQuickItem class. My hope is that one day we will be able to transition to QtQuick for painting scene, but in meanwhile it makes more sense to have a minimalistic internal item class. The WindowItem class represents a window. The SurfaceItem class represents the contents of either an X11, or a Wayland, or an internal surface. The DecorationItem and the ShadowItem class represent the server-side deco and drop-shadow, respectively. At the moment, the SurfaceItem is bound to the scene window, but the long term plan is to break that connection so we could re-use the SurfaceItem for things such as software cursors and drag-and-drop additional icons. One of the responsibilities of the Item is to schedule repaints as needed. Ideally, there shouldn't be any addRepaint() calls in the core code. The Item class schedules repaints on geometry updates. In the future, it also has to request an update if its opacity or visibility changes.
2021-02-04 09:07:20 +00:00
/*
SPDX-FileCopyrightText: 2021 Vlad Zahorodnii <vlad.zahorodnii@kde.org>
SPDX-License-Identifier: GPL-2.0-or-later
*/
#include "surfaceitem.h"
Remove scene window traces in scene items This further decouples scene items from scene windows. The SurfaceItem still needs to access the underlying window, I would like to re-iterate over that later. With this change, it will be possible to introduce WindowItem factory function in the Toplevel class.
2021-08-12 09:07:38 +00:00
#include "deleted.h"
scene: Introduce window items Currently, dealing with sub-surfaces is very difficult due to the scene design being heavily influenced by X11 requirements. The goal of this change is to re-work scene abstractions to make improving the wayland support easier. The Item class is based on the QQuickItem class. My hope is that one day we will be able to transition to QtQuick for painting scene, but in meanwhile it makes more sense to have a minimalistic internal item class. The WindowItem class represents a window. The SurfaceItem class represents the contents of either an X11, or a Wayland, or an internal surface. The DecorationItem and the ShadowItem class represent the server-side deco and drop-shadow, respectively. At the moment, the SurfaceItem is bound to the scene window, but the long term plan is to break that connection so we could re-use the SurfaceItem for things such as software cursors and drag-and-drop additional icons. One of the responsibilities of the Item is to schedule repaints as needed. Ideally, there shouldn't be any addRepaint() calls in the core code. The Item class schedules repaints on geometry updates. In the future, it also has to request an update if its opacity or visibility changes.
2021-02-04 09:07:20 +00:00
namespace KWin
{
Rename AbstractClient to Window
2022-04-22 17:39:12 +00:00
SurfaceItem::SurfaceItem(Window *window, Item *parent)
Remove scene window traces in scene items This further decouples scene items from scene windows. The SurfaceItem still needs to access the underlying window, I would like to re-iterate over that later. With this change, it will be possible to introduce WindowItem factory function in the Toplevel class.
2021-08-12 09:07:38 +00:00
: Item(parent)
, m_window(window)
scene: Introduce window items Currently, dealing with sub-surfaces is very difficult due to the scene design being heavily influenced by X11 requirements. The goal of this change is to re-work scene abstractions to make improving the wayland support easier. The Item class is based on the QQuickItem class. My hope is that one day we will be able to transition to QtQuick for painting scene, but in meanwhile it makes more sense to have a minimalistic internal item class. The WindowItem class represents a window. The SurfaceItem class represents the contents of either an X11, or a Wayland, or an internal surface. The DecorationItem and the ShadowItem class represent the server-side deco and drop-shadow, respectively. At the moment, the SurfaceItem is bound to the scene window, but the long term plan is to break that connection so we could re-use the SurfaceItem for things such as software cursors and drag-and-drop additional icons. One of the responsibilities of the Item is to schedule repaints as needed. Ideally, there shouldn't be any addRepaint() calls in the core code. The Item class schedules repaints on geometry updates. In the future, it also has to request an update if its opacity or visibility changes.
2021-02-04 09:07:20 +00:00
{
Rename AbstractClient to Window
2022-04-22 17:39:12 +00:00
connect(window, &Window::windowClosed, this, &SurfaceItem::handleWindowClosed);
Remove scene window traces in scene items This further decouples scene items from scene windows. The SurfaceItem still needs to access the underlying window, I would like to re-iterate over that later. With this change, it will be possible to introduce WindowItem factory function in the Toplevel class.
2021-08-12 09:07:38 +00:00
}
Rename AbstractClient to Window
2022-04-22 17:39:12 +00:00
Window *SurfaceItem::window() const
Remove scene window traces in scene items This further decouples scene items from scene windows. The SurfaceItem still needs to access the underlying window, I would like to re-iterate over that later. With this change, it will be possible to introduce WindowItem factory function in the Toplevel class.
2021-08-12 09:07:38 +00:00
{
return m_window;
}
Rename AbstractClient to Window
2022-04-22 17:39:12 +00:00
void SurfaceItem::handleWindowClosed(Window *original, Deleted *deleted)
Remove scene window traces in scene items This further decouples scene items from scene windows. The SurfaceItem still needs to access the underlying window, I would like to re-iterate over that later. With this change, it will be possible to introduce WindowItem factory function in the Toplevel class.
2021-08-12 09:07:38 +00:00
{
Q_UNUSED(original)
m_window = deleted;
scene: Introduce window items Currently, dealing with sub-surfaces is very difficult due to the scene design being heavily influenced by X11 requirements. The goal of this change is to re-work scene abstractions to make improving the wayland support easier. The Item class is based on the QQuickItem class. My hope is that one day we will be able to transition to QtQuick for painting scene, but in meanwhile it makes more sense to have a minimalistic internal item class. The WindowItem class represents a window. The SurfaceItem class represents the contents of either an X11, or a Wayland, or an internal surface. The DecorationItem and the ShadowItem class represent the server-side deco and drop-shadow, respectively. At the moment, the SurfaceItem is bound to the scene window, but the long term plan is to break that connection so we could re-use the SurfaceItem for things such as software cursors and drag-and-drop additional icons. One of the responsibilities of the Item is to schedule repaints as needed. Ideally, there shouldn't be any addRepaint() calls in the core code. The Item class schedules repaints on geometry updates. In the future, it also has to request an update if its opacity or visibility changes.
2021-02-04 09:07:20 +00:00
}
wayland: Cache last surface-to-buffer matrix If window quads need to be generated after the wl_surface is destroyed, the SurfaceItemWayland::mapToBuffer() function will return wrong values. In order to fix that, we need to store the last surface-to-buffer matrix in SurfaceItem.
2021-07-21 19:25:42 +00:00
QMatrix4x4 SurfaceItem::surfaceToBufferMatrix() const
{
return m_surfaceToBufferMatrix;
}
void SurfaceItem::setSurfaceToBufferMatrix(const QMatrix4x4 &matrix)
{
m_surfaceToBufferMatrix = matrix;
}
scene: Introduce window items Currently, dealing with sub-surfaces is very difficult due to the scene design being heavily influenced by X11 requirements. The goal of this change is to re-work scene abstractions to make improving the wayland support easier. The Item class is based on the QQuickItem class. My hope is that one day we will be able to transition to QtQuick for painting scene, but in meanwhile it makes more sense to have a minimalistic internal item class. The WindowItem class represents a window. The SurfaceItem class represents the contents of either an X11, or a Wayland, or an internal surface. The DecorationItem and the ShadowItem class represent the server-side deco and drop-shadow, respectively. At the moment, the SurfaceItem is bound to the scene window, but the long term plan is to break that connection so we could re-use the SurfaceItem for things such as software cursors and drag-and-drop additional icons. One of the responsibilities of the Item is to schedule repaints as needed. Ideally, there shouldn't be any addRepaint() calls in the core code. The Item class schedules repaints on geometry updates. In the future, it also has to request an update if its opacity or visibility changes.
2021-02-04 09:07:20 +00:00
void SurfaceItem::addDamage(const QRegion &region)
{
m_damage += region;
scheduleRepaint(region);
Remove scene window traces in scene items This further decouples scene items from scene windows. The SurfaceItem still needs to access the underlying window, I would like to re-iterate over that later. With this change, it will be possible to introduce WindowItem factory function in the Toplevel class.
2021-08-12 09:07:38 +00:00
Q_EMIT m_window->damaged(m_window, region);
scene: Introduce window items Currently, dealing with sub-surfaces is very difficult due to the scene design being heavily influenced by X11 requirements. The goal of this change is to re-work scene abstractions to make improving the wayland support easier. The Item class is based on the QQuickItem class. My hope is that one day we will be able to transition to QtQuick for painting scene, but in meanwhile it makes more sense to have a minimalistic internal item class. The WindowItem class represents a window. The SurfaceItem class represents the contents of either an X11, or a Wayland, or an internal surface. The DecorationItem and the ShadowItem class represent the server-side deco and drop-shadow, respectively. At the moment, the SurfaceItem is bound to the scene window, but the long term plan is to break that connection so we could re-use the SurfaceItem for things such as software cursors and drag-and-drop additional icons. One of the responsibilities of the Item is to schedule repaints as needed. Ideally, there shouldn't be any addRepaint() calls in the core code. The Item class schedules repaints on geometry updates. In the future, it also has to request an update if its opacity or visibility changes.
2021-02-04 09:07:20 +00:00
}
void SurfaceItem::resetDamage()
{
m_damage = QRegion();
}
QRegion SurfaceItem::damage() const
{
return m_damage;
}
Decouple window pixmaps from scene windows One of the scene redesign goals is to make wayland surface items re-usable. So we have the same rendering path for drag-and-drop icons, software cursors, and window surfaces. The biggest issue at the moment is that window pixmaps are tightly coupled with scene windows. This change de-couples window pixmaps from scene windows. In order to achieve that, some architecture changes were made. The WindowPixmap class was replaced with the SurfacePixmap class. A surface pixmap is created by a surface item. Under the hood, a SurfacePixmap will create a PlatformSurfaceTexture object, which contains all the information necessary for the renderer. The SceneOpenGLTexture class was removed. However, the GLX and the EGL on X11 backends still mess with GLTexture's internals.
2021-04-09 07:06:04 +00:00
SurfacePixmap *SurfaceItem::pixmap() const
scene: Introduce window items Currently, dealing with sub-surfaces is very difficult due to the scene design being heavily influenced by X11 requirements. The goal of this change is to re-work scene abstractions to make improving the wayland support easier. The Item class is based on the QQuickItem class. My hope is that one day we will be able to transition to QtQuick for painting scene, but in meanwhile it makes more sense to have a minimalistic internal item class. The WindowItem class represents a window. The SurfaceItem class represents the contents of either an X11, or a Wayland, or an internal surface. The DecorationItem and the ShadowItem class represent the server-side deco and drop-shadow, respectively. At the moment, the SurfaceItem is bound to the scene window, but the long term plan is to break that connection so we could re-use the SurfaceItem for things such as software cursors and drag-and-drop additional icons. One of the responsibilities of the Item is to schedule repaints as needed. Ideally, there shouldn't be any addRepaint() calls in the core code. The Item class schedules repaints on geometry updates. In the future, it also has to request an update if its opacity or visibility changes.
2021-02-04 09:07:20 +00:00
{
Decouple window pixmaps from scene windows One of the scene redesign goals is to make wayland surface items re-usable. So we have the same rendering path for drag-and-drop icons, software cursors, and window surfaces. The biggest issue at the moment is that window pixmaps are tightly coupled with scene windows. This change de-couples window pixmaps from scene windows. In order to achieve that, some architecture changes were made. The WindowPixmap class was replaced with the SurfacePixmap class. A surface pixmap is created by a surface item. Under the hood, a SurfacePixmap will create a PlatformSurfaceTexture object, which contains all the information necessary for the renderer. The SceneOpenGLTexture class was removed. However, the GLX and the EGL on X11 backends still mess with GLTexture's internals.
2021-04-09 07:06:04 +00:00
if (m_pixmap && m_pixmap->isValid()) {
return m_pixmap.data();
scene: Introduce window items Currently, dealing with sub-surfaces is very difficult due to the scene design being heavily influenced by X11 requirements. The goal of this change is to re-work scene abstractions to make improving the wayland support easier. The Item class is based on the QQuickItem class. My hope is that one day we will be able to transition to QtQuick for painting scene, but in meanwhile it makes more sense to have a minimalistic internal item class. The WindowItem class represents a window. The SurfaceItem class represents the contents of either an X11, or a Wayland, or an internal surface. The DecorationItem and the ShadowItem class represent the server-side deco and drop-shadow, respectively. At the moment, the SurfaceItem is bound to the scene window, but the long term plan is to break that connection so we could re-use the SurfaceItem for things such as software cursors and drag-and-drop additional icons. One of the responsibilities of the Item is to schedule repaints as needed. Ideally, there shouldn't be any addRepaint() calls in the core code. The Item class schedules repaints on geometry updates. In the future, it also has to request an update if its opacity or visibility changes.
2021-02-04 09:07:20 +00:00
}
Decouple window pixmaps from scene windows One of the scene redesign goals is to make wayland surface items re-usable. So we have the same rendering path for drag-and-drop icons, software cursors, and window surfaces. The biggest issue at the moment is that window pixmaps are tightly coupled with scene windows. This change de-couples window pixmaps from scene windows. In order to achieve that, some architecture changes were made. The WindowPixmap class was replaced with the SurfacePixmap class. A surface pixmap is created by a surface item. Under the hood, a SurfacePixmap will create a PlatformSurfaceTexture object, which contains all the information necessary for the renderer. The SceneOpenGLTexture class was removed. However, the GLX and the EGL on X11 backends still mess with GLTexture's internals.
2021-04-09 07:06:04 +00:00
if (m_previousPixmap && m_previousPixmap->isValid()) {
return m_previousPixmap.data();
scene: Introduce window items Currently, dealing with sub-surfaces is very difficult due to the scene design being heavily influenced by X11 requirements. The goal of this change is to re-work scene abstractions to make improving the wayland support easier. The Item class is based on the QQuickItem class. My hope is that one day we will be able to transition to QtQuick for painting scene, but in meanwhile it makes more sense to have a minimalistic internal item class. The WindowItem class represents a window. The SurfaceItem class represents the contents of either an X11, or a Wayland, or an internal surface. The DecorationItem and the ShadowItem class represent the server-side deco and drop-shadow, respectively. At the moment, the SurfaceItem is bound to the scene window, but the long term plan is to break that connection so we could re-use the SurfaceItem for things such as software cursors and drag-and-drop additional icons. One of the responsibilities of the Item is to schedule repaints as needed. Ideally, there shouldn't be any addRepaint() calls in the core code. The Item class schedules repaints on geometry updates. In the future, it also has to request an update if its opacity or visibility changes.
2021-02-04 09:07:20 +00:00
}
return nullptr;
}
Decouple window pixmaps from scene windows One of the scene redesign goals is to make wayland surface items re-usable. So we have the same rendering path for drag-and-drop icons, software cursors, and window surfaces. The biggest issue at the moment is that window pixmaps are tightly coupled with scene windows. This change de-couples window pixmaps from scene windows. In order to achieve that, some architecture changes were made. The WindowPixmap class was replaced with the SurfacePixmap class. A surface pixmap is created by a surface item. Under the hood, a SurfacePixmap will create a PlatformSurfaceTexture object, which contains all the information necessary for the renderer. The SceneOpenGLTexture class was removed. However, the GLX and the EGL on X11 backends still mess with GLTexture's internals.
2021-04-09 07:06:04 +00:00
SurfacePixmap *SurfaceItem::previousPixmap() const
scene: Introduce window items Currently, dealing with sub-surfaces is very difficult due to the scene design being heavily influenced by X11 requirements. The goal of this change is to re-work scene abstractions to make improving the wayland support easier. The Item class is based on the QQuickItem class. My hope is that one day we will be able to transition to QtQuick for painting scene, but in meanwhile it makes more sense to have a minimalistic internal item class. The WindowItem class represents a window. The SurfaceItem class represents the contents of either an X11, or a Wayland, or an internal surface. The DecorationItem and the ShadowItem class represent the server-side deco and drop-shadow, respectively. At the moment, the SurfaceItem is bound to the scene window, but the long term plan is to break that connection so we could re-use the SurfaceItem for things such as software cursors and drag-and-drop additional icons. One of the responsibilities of the Item is to schedule repaints as needed. Ideally, there shouldn't be any addRepaint() calls in the core code. The Item class schedules repaints on geometry updates. In the future, it also has to request an update if its opacity or visibility changes.
2021-02-04 09:07:20 +00:00
{
Decouple window pixmaps from scene windows One of the scene redesign goals is to make wayland surface items re-usable. So we have the same rendering path for drag-and-drop icons, software cursors, and window surfaces. The biggest issue at the moment is that window pixmaps are tightly coupled with scene windows. This change de-couples window pixmaps from scene windows. In order to achieve that, some architecture changes were made. The WindowPixmap class was replaced with the SurfacePixmap class. A surface pixmap is created by a surface item. Under the hood, a SurfacePixmap will create a PlatformSurfaceTexture object, which contains all the information necessary for the renderer. The SceneOpenGLTexture class was removed. However, the GLX and the EGL on X11 backends still mess with GLTexture's internals.
2021-04-09 07:06:04 +00:00
return m_previousPixmap.data();
scene: Introduce window items Currently, dealing with sub-surfaces is very difficult due to the scene design being heavily influenced by X11 requirements. The goal of this change is to re-work scene abstractions to make improving the wayland support easier. The Item class is based on the QQuickItem class. My hope is that one day we will be able to transition to QtQuick for painting scene, but in meanwhile it makes more sense to have a minimalistic internal item class. The WindowItem class represents a window. The SurfaceItem class represents the contents of either an X11, or a Wayland, or an internal surface. The DecorationItem and the ShadowItem class represent the server-side deco and drop-shadow, respectively. At the moment, the SurfaceItem is bound to the scene window, but the long term plan is to break that connection so we could re-use the SurfaceItem for things such as software cursors and drag-and-drop additional icons. One of the responsibilities of the Item is to schedule repaints as needed. Ideally, there shouldn't be any addRepaint() calls in the core code. The Item class schedules repaints on geometry updates. In the future, it also has to request an update if its opacity or visibility changes.
2021-02-04 09:07:20 +00:00
}
void SurfaceItem::referencePreviousPixmap()
{
Decouple window pixmaps from scene windows One of the scene redesign goals is to make wayland surface items re-usable. So we have the same rendering path for drag-and-drop icons, software cursors, and window surfaces. The biggest issue at the moment is that window pixmaps are tightly coupled with scene windows. This change de-couples window pixmaps from scene windows. In order to achieve that, some architecture changes were made. The WindowPixmap class was replaced with the SurfacePixmap class. A surface pixmap is created by a surface item. Under the hood, a SurfacePixmap will create a PlatformSurfaceTexture object, which contains all the information necessary for the renderer. The SceneOpenGLTexture class was removed. However, the GLX and the EGL on X11 backends still mess with GLTexture's internals.
2021-04-09 07:06:04 +00:00
if (m_previousPixmap && m_previousPixmap->isDiscarded()) {
scene: Introduce window items Currently, dealing with sub-surfaces is very difficult due to the scene design being heavily influenced by X11 requirements. The goal of this change is to re-work scene abstractions to make improving the wayland support easier. The Item class is based on the QQuickItem class. My hope is that one day we will be able to transition to QtQuick for painting scene, but in meanwhile it makes more sense to have a minimalistic internal item class. The WindowItem class represents a window. The SurfaceItem class represents the contents of either an X11, or a Wayland, or an internal surface. The DecorationItem and the ShadowItem class represent the server-side deco and drop-shadow, respectively. At the moment, the SurfaceItem is bound to the scene window, but the long term plan is to break that connection so we could re-use the SurfaceItem for things such as software cursors and drag-and-drop additional icons. One of the responsibilities of the Item is to schedule repaints as needed. Ideally, there shouldn't be any addRepaint() calls in the core code. The Item class schedules repaints on geometry updates. In the future, it also has to request an update if its opacity or visibility changes.
2021-02-04 09:07:20 +00:00
m_referencePixmapCounter++;
}
}
void SurfaceItem::unreferencePreviousPixmap()
{
Decouple window pixmaps from scene windows One of the scene redesign goals is to make wayland surface items re-usable. So we have the same rendering path for drag-and-drop icons, software cursors, and window surfaces. The biggest issue at the moment is that window pixmaps are tightly coupled with scene windows. This change de-couples window pixmaps from scene windows. In order to achieve that, some architecture changes were made. The WindowPixmap class was replaced with the SurfacePixmap class. A surface pixmap is created by a surface item. Under the hood, a SurfacePixmap will create a PlatformSurfaceTexture object, which contains all the information necessary for the renderer. The SceneOpenGLTexture class was removed. However, the GLX and the EGL on X11 backends still mess with GLTexture's internals.
2021-04-09 07:06:04 +00:00
if (!m_previousPixmap || !m_previousPixmap->isDiscarded()) {
scene: Introduce window items Currently, dealing with sub-surfaces is very difficult due to the scene design being heavily influenced by X11 requirements. The goal of this change is to re-work scene abstractions to make improving the wayland support easier. The Item class is based on the QQuickItem class. My hope is that one day we will be able to transition to QtQuick for painting scene, but in meanwhile it makes more sense to have a minimalistic internal item class. The WindowItem class represents a window. The SurfaceItem class represents the contents of either an X11, or a Wayland, or an internal surface. The DecorationItem and the ShadowItem class represent the server-side deco and drop-shadow, respectively. At the moment, the SurfaceItem is bound to the scene window, but the long term plan is to break that connection so we could re-use the SurfaceItem for things such as software cursors and drag-and-drop additional icons. One of the responsibilities of the Item is to schedule repaints as needed. Ideally, there shouldn't be any addRepaint() calls in the core code. The Item class schedules repaints on geometry updates. In the future, it also has to request an update if its opacity or visibility changes.
2021-02-04 09:07:20 +00:00
return;
}
m_referencePixmapCounter--;
if (m_referencePixmapCounter == 0) {
Decouple window pixmaps from scene windows One of the scene redesign goals is to make wayland surface items re-usable. So we have the same rendering path for drag-and-drop icons, software cursors, and window surfaces. The biggest issue at the moment is that window pixmaps are tightly coupled with scene windows. This change de-couples window pixmaps from scene windows. In order to achieve that, some architecture changes were made. The WindowPixmap class was replaced with the SurfacePixmap class. A surface pixmap is created by a surface item. Under the hood, a SurfacePixmap will create a PlatformSurfaceTexture object, which contains all the information necessary for the renderer. The SceneOpenGLTexture class was removed. However, the GLX and the EGL on X11 backends still mess with GLTexture's internals.
2021-04-09 07:06:04 +00:00
m_previousPixmap.reset();
scene: Introduce window items Currently, dealing with sub-surfaces is very difficult due to the scene design being heavily influenced by X11 requirements. The goal of this change is to re-work scene abstractions to make improving the wayland support easier. The Item class is based on the QQuickItem class. My hope is that one day we will be able to transition to QtQuick for painting scene, but in meanwhile it makes more sense to have a minimalistic internal item class. The WindowItem class represents a window. The SurfaceItem class represents the contents of either an X11, or a Wayland, or an internal surface. The DecorationItem and the ShadowItem class represent the server-side deco and drop-shadow, respectively. At the moment, the SurfaceItem is bound to the scene window, but the long term plan is to break that connection so we could re-use the SurfaceItem for things such as software cursors and drag-and-drop additional icons. One of the responsibilities of the Item is to schedule repaints as needed. Ideally, there shouldn't be any addRepaint() calls in the core code. The Item class schedules repaints on geometry updates. In the future, it also has to request an update if its opacity or visibility changes.
2021-02-04 09:07:20 +00:00
}
}
void SurfaceItem::updatePixmap()
{
Decouple window pixmaps from scene windows One of the scene redesign goals is to make wayland surface items re-usable. So we have the same rendering path for drag-and-drop icons, software cursors, and window surfaces. The biggest issue at the moment is that window pixmaps are tightly coupled with scene windows. This change de-couples window pixmaps from scene windows. In order to achieve that, some architecture changes were made. The WindowPixmap class was replaced with the SurfacePixmap class. A surface pixmap is created by a surface item. Under the hood, a SurfacePixmap will create a PlatformSurfaceTexture object, which contains all the information necessary for the renderer. The SceneOpenGLTexture class was removed. However, the GLX and the EGL on X11 backends still mess with GLTexture's internals.
2021-04-09 07:06:04 +00:00
if (m_pixmap.isNull()) {
m_pixmap.reset(createPixmap());
scene: Introduce window items Currently, dealing with sub-surfaces is very difficult due to the scene design being heavily influenced by X11 requirements. The goal of this change is to re-work scene abstractions to make improving the wayland support easier. The Item class is based on the QQuickItem class. My hope is that one day we will be able to transition to QtQuick for painting scene, but in meanwhile it makes more sense to have a minimalistic internal item class. The WindowItem class represents a window. The SurfaceItem class represents the contents of either an X11, or a Wayland, or an internal surface. The DecorationItem and the ShadowItem class represent the server-side deco and drop-shadow, respectively. At the moment, the SurfaceItem is bound to the scene window, but the long term plan is to break that connection so we could re-use the SurfaceItem for things such as software cursors and drag-and-drop additional icons. One of the responsibilities of the Item is to schedule repaints as needed. Ideally, there shouldn't be any addRepaint() calls in the core code. The Item class schedules repaints on geometry updates. In the future, it also has to request an update if its opacity or visibility changes.
2021-02-04 09:07:20 +00:00
}
Decouple window pixmaps from scene windows One of the scene redesign goals is to make wayland surface items re-usable. So we have the same rendering path for drag-and-drop icons, software cursors, and window surfaces. The biggest issue at the moment is that window pixmaps are tightly coupled with scene windows. This change de-couples window pixmaps from scene windows. In order to achieve that, some architecture changes were made. The WindowPixmap class was replaced with the SurfacePixmap class. A surface pixmap is created by a surface item. Under the hood, a SurfacePixmap will create a PlatformSurfaceTexture object, which contains all the information necessary for the renderer. The SceneOpenGLTexture class was removed. However, the GLX and the EGL on X11 backends still mess with GLTexture's internals.
2021-04-09 07:06:04 +00:00
if (m_pixmap->isValid()) {
m_pixmap->update();
scene: Introduce window items Currently, dealing with sub-surfaces is very difficult due to the scene design being heavily influenced by X11 requirements. The goal of this change is to re-work scene abstractions to make improving the wayland support easier. The Item class is based on the QQuickItem class. My hope is that one day we will be able to transition to QtQuick for painting scene, but in meanwhile it makes more sense to have a minimalistic internal item class. The WindowItem class represents a window. The SurfaceItem class represents the contents of either an X11, or a Wayland, or an internal surface. The DecorationItem and the ShadowItem class represent the server-side deco and drop-shadow, respectively. At the moment, the SurfaceItem is bound to the scene window, but the long term plan is to break that connection so we could re-use the SurfaceItem for things such as software cursors and drag-and-drop additional icons. One of the responsibilities of the Item is to schedule repaints as needed. Ideally, there shouldn't be any addRepaint() calls in the core code. The Item class schedules repaints on geometry updates. In the future, it also has to request an update if its opacity or visibility changes.
2021-02-04 09:07:20 +00:00
} else {
Decouple window pixmaps from scene windows One of the scene redesign goals is to make wayland surface items re-usable. So we have the same rendering path for drag-and-drop icons, software cursors, and window surfaces. The biggest issue at the moment is that window pixmaps are tightly coupled with scene windows. This change de-couples window pixmaps from scene windows. In order to achieve that, some architecture changes were made. The WindowPixmap class was replaced with the SurfacePixmap class. A surface pixmap is created by a surface item. Under the hood, a SurfacePixmap will create a PlatformSurfaceTexture object, which contains all the information necessary for the renderer. The SceneOpenGLTexture class was removed. However, the GLX and the EGL on X11 backends still mess with GLTexture's internals.
2021-04-09 07:06:04 +00:00
m_pixmap->create();
if (m_pixmap->isValid()) {
scene: Fix previous pixmap ref'ing discardPixmap() increases the reference counter, but there's no matching place where the ref count is decreased, which results in the previous pixmap not being released even if it's not needed anymore.
2021-09-15 13:13:08 +00:00
unreferencePreviousPixmap();
scene: Introduce window items Currently, dealing with sub-surfaces is very difficult due to the scene design being heavily influenced by X11 requirements. The goal of this change is to re-work scene abstractions to make improving the wayland support easier. The Item class is based on the QQuickItem class. My hope is that one day we will be able to transition to QtQuick for painting scene, but in meanwhile it makes more sense to have a minimalistic internal item class. The WindowItem class represents a window. The SurfaceItem class represents the contents of either an X11, or a Wayland, or an internal surface. The DecorationItem and the ShadowItem class represent the server-side deco and drop-shadow, respectively. At the moment, the SurfaceItem is bound to the scene window, but the long term plan is to break that connection so we could re-use the SurfaceItem for things such as software cursors and drag-and-drop additional icons. One of the responsibilities of the Item is to schedule repaints as needed. Ideally, there shouldn't be any addRepaint() calls in the core code. The Item class schedules repaints on geometry updates. In the future, it also has to request an update if its opacity or visibility changes.
2021-02-04 09:07:20 +00:00
discardQuads();
}
}
}
void SurfaceItem::discardPixmap()
{
Decouple window pixmaps from scene windows One of the scene redesign goals is to make wayland surface items re-usable. So we have the same rendering path for drag-and-drop icons, software cursors, and window surfaces. The biggest issue at the moment is that window pixmaps are tightly coupled with scene windows. This change de-couples window pixmaps from scene windows. In order to achieve that, some architecture changes were made. The WindowPixmap class was replaced with the SurfacePixmap class. A surface pixmap is created by a surface item. Under the hood, a SurfacePixmap will create a PlatformSurfaceTexture object, which contains all the information necessary for the renderer. The SceneOpenGLTexture class was removed. However, the GLX and the EGL on X11 backends still mess with GLTexture's internals.
2021-04-09 07:06:04 +00:00
if (!m_pixmap.isNull()) {
if (m_pixmap->isValid()) {
m_previousPixmap.reset(m_pixmap.take());
m_previousPixmap->markAsDiscarded();
scene: Fix previous pixmap ref'ing discardPixmap() increases the reference counter, but there's no matching place where the ref count is decreased, which results in the previous pixmap not being released even if it's not needed anymore.
2021-09-15 13:13:08 +00:00
referencePreviousPixmap();
scene: Introduce window items Currently, dealing with sub-surfaces is very difficult due to the scene design being heavily influenced by X11 requirements. The goal of this change is to re-work scene abstractions to make improving the wayland support easier. The Item class is based on the QQuickItem class. My hope is that one day we will be able to transition to QtQuick for painting scene, but in meanwhile it makes more sense to have a minimalistic internal item class. The WindowItem class represents a window. The SurfaceItem class represents the contents of either an X11, or a Wayland, or an internal surface. The DecorationItem and the ShadowItem class represent the server-side deco and drop-shadow, respectively. At the moment, the SurfaceItem is bound to the scene window, but the long term plan is to break that connection so we could re-use the SurfaceItem for things such as software cursors and drag-and-drop additional icons. One of the responsibilities of the Item is to schedule repaints as needed. Ideally, there shouldn't be any addRepaint() calls in the core code. The Item class schedules repaints on geometry updates. In the future, it also has to request an update if its opacity or visibility changes.
2021-02-04 09:07:20 +00:00
} else {
Decouple window pixmaps from scene windows One of the scene redesign goals is to make wayland surface items re-usable. So we have the same rendering path for drag-and-drop icons, software cursors, and window surfaces. The biggest issue at the moment is that window pixmaps are tightly coupled with scene windows. This change de-couples window pixmaps from scene windows. In order to achieve that, some architecture changes were made. The WindowPixmap class was replaced with the SurfacePixmap class. A surface pixmap is created by a surface item. Under the hood, a SurfacePixmap will create a PlatformSurfaceTexture object, which contains all the information necessary for the renderer. The SceneOpenGLTexture class was removed. However, the GLX and the EGL on X11 backends still mess with GLTexture's internals.
2021-04-09 07:06:04 +00:00
m_pixmap.reset();
scene: Introduce window items Currently, dealing with sub-surfaces is very difficult due to the scene design being heavily influenced by X11 requirements. The goal of this change is to re-work scene abstractions to make improving the wayland support easier. The Item class is based on the QQuickItem class. My hope is that one day we will be able to transition to QtQuick for painting scene, but in meanwhile it makes more sense to have a minimalistic internal item class. The WindowItem class represents a window. The SurfaceItem class represents the contents of either an X11, or a Wayland, or an internal surface. The DecorationItem and the ShadowItem class represent the server-side deco and drop-shadow, respectively. At the moment, the SurfaceItem is bound to the scene window, but the long term plan is to break that connection so we could re-use the SurfaceItem for things such as software cursors and drag-and-drop additional icons. One of the responsibilities of the Item is to schedule repaints as needed. Ideally, there shouldn't be any addRepaint() calls in the core code. The Item class schedules repaints on geometry updates. In the future, it also has to request an update if its opacity or visibility changes.
2021-02-04 09:07:20 +00:00
}
}
addDamage(rect());
}
void SurfaceItem::preprocess()
{
updatePixmap();
}
Refactor window quad handling The scene items depend on the scene windows for caching window quads. The goal of this change is to move window quads management to item. Merging window quads in one list and then splitting them is inefficient, it will be highly desirable if window quads are removed from the public api so we can optimize window quad management. With this change, the window quad type becomes irrelevant to render backends for the most part. Note that the Xrender backend is a bit nitpicky about window quads, so the shadow item doesn't create generic "WindowQuadShadow" quads anymore.
2021-05-21 10:51:23 +00:00
WindowQuadList SurfaceItem::buildQuads() const
{
const QRegion region = shape();
WindowQuadList quads;
quads.reserve(region.rectCount());
for (const QRectF rect : region) {
scene: Improve window quad management At the moment, we handle window quads inefficiently. Window quads from all items are merged into a single list just to be broken up again. This change removes window quads from libkwineffects. This allows us to handle window quads efficiently. Furthermore, we could optimize methods such as WindowVertex::left() and so on. KWin spends reasonable amount of time in those methods when many windows have to be composited. It's a necessary prerequisite for making wl_surface painting code role agnostic.
2021-06-10 10:32:37 +00:00
WindowQuad quad;
Refactor window quad handling The scene items depend on the scene windows for caching window quads. The goal of this change is to move window quads management to item. Merging window quads in one list and then splitting them is inefficient, it will be highly desirable if window quads are removed from the public api so we can optimize window quad management. With this change, the window quad type becomes irrelevant to render backends for the most part. Note that the Xrender backend is a bit nitpicky about window quads, so the shadow item doesn't create generic "WindowQuadShadow" quads anymore.
2021-05-21 10:51:23 +00:00
wayland: Cache last surface-to-buffer matrix If window quads need to be generated after the wl_surface is destroyed, the SurfaceItemWayland::mapToBuffer() function will return wrong values. In order to fix that, we need to store the last surface-to-buffer matrix in SurfaceItem.
2021-07-21 19:25:42 +00:00
const QPointF bufferTopLeft = m_surfaceToBufferMatrix.map(rect.topLeft());
const QPointF bufferTopRight = m_surfaceToBufferMatrix.map(rect.topRight());
const QPointF bufferBottomRight = m_surfaceToBufferMatrix.map(rect.bottomRight());
const QPointF bufferBottomLeft = m_surfaceToBufferMatrix.map(rect.bottomLeft());
Refactor window quad handling The scene items depend on the scene windows for caching window quads. The goal of this change is to move window quads management to item. Merging window quads in one list and then splitting them is inefficient, it will be highly desirable if window quads are removed from the public api so we can optimize window quad management. With this change, the window quad type becomes irrelevant to render backends for the most part. Note that the Xrender backend is a bit nitpicky about window quads, so the shadow item doesn't create generic "WindowQuadShadow" quads anymore.
2021-05-21 10:51:23 +00:00
scene: Generate quads in item local coordinate space Window quads need to be in some coordinate space. Since we want items to be used not only for rendering windows, window-local coordinates do not suffice. This change makes scene items generate quads in the item-local coordinate space. The model matrix is used to map the quads to the global screen coordinate system from the item coordinate space. Since the quads are in the item local coordinate space, the mvp matrix needs to be updated on every draw call. Given the render data, tracking the last mvp matrix won't result in less glUniform calls. If this indeed becomes a serious performance bottleneck, we can explore the possibility of dumping mvp matrices in a UBO, which have been introduced in OpenGL 3.1.
2021-06-10 10:02:10 +00:00
quad[0] = WindowVertex(rect.topLeft(), bufferTopLeft);
quad[1] = WindowVertex(rect.topRight(), bufferTopRight);
quad[2] = WindowVertex(rect.bottomRight(), bufferBottomRight);
quad[3] = WindowVertex(rect.bottomLeft(), bufferBottomLeft);
Refactor window quad handling The scene items depend on the scene windows for caching window quads. The goal of this change is to move window quads management to item. Merging window quads in one list and then splitting them is inefficient, it will be highly desirable if window quads are removed from the public api so we can optimize window quad management. With this change, the window quad type becomes irrelevant to render backends for the most part. Note that the Xrender backend is a bit nitpicky about window quads, so the shadow item doesn't create generic "WindowQuadShadow" quads anymore.
2021-05-21 10:51:23 +00:00
quads << quad;
}
return quads;
}
Rename PlatformSurfaceTexture to SurfaceTexture This is, primarily, to make naming consistent with SurfaceItem, SurfacePixmap and just "Surface" in the future.
2021-10-20 14:58:58 +00:00
SurfaceTexture::~SurfaceTexture()
Decouple window pixmaps from scene windows One of the scene redesign goals is to make wayland surface items re-usable. So we have the same rendering path for drag-and-drop icons, software cursors, and window surfaces. The biggest issue at the moment is that window pixmaps are tightly coupled with scene windows. This change de-couples window pixmaps from scene windows. In order to achieve that, some architecture changes were made. The WindowPixmap class was replaced with the SurfacePixmap class. A surface pixmap is created by a surface item. Under the hood, a SurfacePixmap will create a PlatformSurfaceTexture object, which contains all the information necessary for the renderer. The SceneOpenGLTexture class was removed. However, the GLX and the EGL on X11 backends still mess with GLTexture's internals.
2021-04-09 07:06:04 +00:00
{
}
Rename PlatformSurfaceTexture to SurfaceTexture This is, primarily, to make naming consistent with SurfaceItem, SurfacePixmap and just "Surface" in the future.
2021-10-20 14:58:58 +00:00
SurfacePixmap::SurfacePixmap(SurfaceTexture *texture, QObject *parent)
Decouple window pixmaps from scene windows One of the scene redesign goals is to make wayland surface items re-usable. So we have the same rendering path for drag-and-drop icons, software cursors, and window surfaces. The biggest issue at the moment is that window pixmaps are tightly coupled with scene windows. This change de-couples window pixmaps from scene windows. In order to achieve that, some architecture changes were made. The WindowPixmap class was replaced with the SurfacePixmap class. A surface pixmap is created by a surface item. Under the hood, a SurfacePixmap will create a PlatformSurfaceTexture object, which contains all the information necessary for the renderer. The SceneOpenGLTexture class was removed. However, the GLX and the EGL on X11 backends still mess with GLTexture's internals.
2021-04-09 07:06:04 +00:00
: QObject(parent)
Rename PlatformSurfaceTexture to SurfaceTexture This is, primarily, to make naming consistent with SurfaceItem, SurfacePixmap and just "Surface" in the future.
2021-10-20 14:58:58 +00:00
, m_texture(texture)
Decouple window pixmaps from scene windows One of the scene redesign goals is to make wayland surface items re-usable. So we have the same rendering path for drag-and-drop icons, software cursors, and window surfaces. The biggest issue at the moment is that window pixmaps are tightly coupled with scene windows. This change de-couples window pixmaps from scene windows. In order to achieve that, some architecture changes were made. The WindowPixmap class was replaced with the SurfacePixmap class. A surface pixmap is created by a surface item. Under the hood, a SurfacePixmap will create a PlatformSurfaceTexture object, which contains all the information necessary for the renderer. The SceneOpenGLTexture class was removed. However, the GLX and the EGL on X11 backends still mess with GLTexture's internals.
2021-04-09 07:06:04 +00:00
{
}
void SurfacePixmap::update()
{
}
Rename PlatformSurfaceTexture to SurfaceTexture This is, primarily, to make naming consistent with SurfaceItem, SurfacePixmap and just "Surface" in the future.
2021-10-20 14:58:58 +00:00
SurfaceTexture *SurfacePixmap::texture() const
Decouple window pixmaps from scene windows One of the scene redesign goals is to make wayland surface items re-usable. So we have the same rendering path for drag-and-drop icons, software cursors, and window surfaces. The biggest issue at the moment is that window pixmaps are tightly coupled with scene windows. This change de-couples window pixmaps from scene windows. In order to achieve that, some architecture changes were made. The WindowPixmap class was replaced with the SurfacePixmap class. A surface pixmap is created by a surface item. Under the hood, a SurfacePixmap will create a PlatformSurfaceTexture object, which contains all the information necessary for the renderer. The SceneOpenGLTexture class was removed. However, the GLX and the EGL on X11 backends still mess with GLTexture's internals.
2021-04-09 07:06:04 +00:00
{
Rename PlatformSurfaceTexture to SurfaceTexture This is, primarily, to make naming consistent with SurfaceItem, SurfacePixmap and just "Surface" in the future.
2021-10-20 14:58:58 +00:00
return m_texture.data();
Decouple window pixmaps from scene windows One of the scene redesign goals is to make wayland surface items re-usable. So we have the same rendering path for drag-and-drop icons, software cursors, and window surfaces. The biggest issue at the moment is that window pixmaps are tightly coupled with scene windows. This change de-couples window pixmaps from scene windows. In order to achieve that, some architecture changes were made. The WindowPixmap class was replaced with the SurfacePixmap class. A surface pixmap is created by a surface item. Under the hood, a SurfacePixmap will create a PlatformSurfaceTexture object, which contains all the information necessary for the renderer. The SceneOpenGLTexture class was removed. However, the GLX and the EGL on X11 backends still mess with GLTexture's internals.
2021-04-09 07:06:04 +00:00
}
bool SurfacePixmap::hasAlphaChannel() const
{
return m_hasAlphaChannel;
}
QSize SurfacePixmap::size() const
{
return m_size;
}
QRect SurfacePixmap::contentsRect() const
{
return m_contentsRect;
}
bool SurfacePixmap::isDiscarded() const
{
return m_isDiscarded;
}
void SurfacePixmap::markAsDiscarded()
{
m_isDiscarded = true;
}
scene: Introduce window items Currently, dealing with sub-surfaces is very difficult due to the scene design being heavily influenced by X11 requirements. The goal of this change is to re-work scene abstractions to make improving the wayland support easier. The Item class is based on the QQuickItem class. My hope is that one day we will be able to transition to QtQuick for painting scene, but in meanwhile it makes more sense to have a minimalistic internal item class. The WindowItem class represents a window. The SurfaceItem class represents the contents of either an X11, or a Wayland, or an internal surface. The DecorationItem and the ShadowItem class represent the server-side deco and drop-shadow, respectively. At the moment, the SurfaceItem is bound to the scene window, but the long term plan is to break that connection so we could re-use the SurfaceItem for things such as software cursors and drag-and-drop additional icons. One of the responsibilities of the Item is to schedule repaints as needed. Ideally, there shouldn't be any addRepaint() calls in the core code. The Item class schedules repaints on geometry updates. In the future, it also has to request an update if its opacity or visibility changes.
2021-02-04 09:07:20 +00:00
} // namespace KWin
Reference in a new issue Copy permalink