2007-04-29 17:35:43 +00:00
|
|
|
########### next target ###############
|
2014-05-07 11:54:36 +00:00
|
|
|
include(ECMSetupVersion)
|
|
|
|
|
|
2014-08-20 13:43:27 +00:00
|
|
|
ecm_setup_version(${PROJECT_VERSION}
|
2014-05-07 11:54:36 +00:00
|
|
|
VARIABLE_PREFIX KWINEFFECTS
|
|
|
|
|
VERSION_HEADER "${CMAKE_CURRENT_BINARY_DIR}/kwineffects_version.h"
|
|
|
|
|
PACKAGE_VERSION_FILE "${CMAKE_CURRENT_BINARY_DIR}/KWinEffectsConfigVersion.cmake"
|
2018-10-03 21:57:15 +00:00
|
|
|
SOVERSION 12
|
2014-05-07 11:54:36 +00:00
|
|
|
)
|
2007-04-29 17:35:43 +00:00
|
|
|
|
2014-03-16 14:31:23 +00:00
|
|
|
### xrenderutils lib ###
|
|
|
|
|
set(kwin_XRENDERUTILS_SRCS
|
|
|
|
|
kwinxrenderutils.cpp
|
2015-07-31 10:07:53 +00:00
|
|
|
logging.cpp
|
2019-09-17 09:15:35 +00:00
|
|
|
)
|
2014-03-16 14:31:23 +00:00
|
|
|
|
|
|
|
|
add_library(kwinxrenderutils SHARED ${kwin_XRENDERUTILS_SRCS})
|
2014-03-16 14:49:21 +00:00
|
|
|
generate_export_header(kwinxrenderutils EXPORT_FILE_NAME kwinxrenderutils_export.h)
|
2014-03-16 14:31:23 +00:00
|
|
|
target_link_libraries(kwinxrenderutils
|
|
|
|
|
PUBLIC
|
|
|
|
|
Qt5::Core
|
|
|
|
|
Qt5::Gui
|
2019-09-18 10:31:02 +00:00
|
|
|
|
2020-04-29 15:18:41 +00:00
|
|
|
Plasma::KWaylandServer
|
2019-09-18 10:31:02 +00:00
|
|
|
|
2019-09-17 09:15:35 +00:00
|
|
|
XCB::RENDER
|
2014-03-16 14:31:23 +00:00
|
|
|
XCB::XCB
|
|
|
|
|
XCB::XFIXES
|
2019-09-17 09:15:35 +00:00
|
|
|
)
|
2014-03-16 14:31:23 +00:00
|
|
|
|
2014-05-07 11:54:36 +00:00
|
|
|
set_target_properties(kwinxrenderutils PROPERTIES
|
|
|
|
|
VERSION ${KWINEFFECTS_VERSION_STRING}
|
|
|
|
|
SOVERSION ${KWINEFFECTS_SOVERSION}
|
|
|
|
|
)
|
2014-03-16 14:31:23 +00:00
|
|
|
set_target_properties(kwinxrenderutils PROPERTIES OUTPUT_NAME ${KWIN_NAME}xrenderutils)
|
|
|
|
|
|
|
|
|
|
install(TARGETS kwinxrenderutils EXPORT kdeworkspaceLibraryTargets ${INSTALL_TARGETS_DEFAULT_ARGS})
|
|
|
|
|
|
2007-04-29 17:35:43 +00:00
|
|
|
### effects lib ###
|
|
|
|
|
set(kwin_EFFECTSLIB_SRCS
|
2011-10-19 23:04:52 +00:00
|
|
|
anidata.cpp
|
|
|
|
|
kwinanimationeffect.cpp
|
[libkwineffects] Introduce API to easily show a QtQuick scene in an effect
Summary:
EffectQuickView/Scene is a convenient class to render a QtQuick
scenegraph into an effect.
Current methods (such as present windows) involve creating an underlying
platform window which is expensive, causes a headache to filter out
again in the rest of the code, and only works as an overlay.
The new class exposes things more natively to an effect where we don't
mess with real windows, we can perform the painting anywhere in the view
and we don't have issues with hiding/closing.
QtQuick has both software and hardware accelerated modes, and kwin also
has 3 render backends. Every combination is supported.
* When used in OpenGL mode for both, we render into an FBO export the
texture ID then it's up to the effect to render that into a scene.
* When using software QtQuick rendering we blit into an image, upload
that into a KWinGLTexture which serves as an abstraction layer and
render that into the scene.
* When using GL for QtQuick and XRender/QPainter in kwin everything is
rendered into the internal FBO, blit and exported as an image.
* When using software rendering for both an image gets passed directly.
Mouse and keyboard events can be forwarded, only if the effect
intercepts them.
The class is meant to be generic enough that we can remove all the
QtQuick code from Aurorae.
The intention is also to replace EffectFrameImpl using this backend and
we can kill all of the EffectFrame code throughout the scenes.
The close button in present windows will also be ported to this,
simplifiying that code base.
Classes that handle the rendering and handling QML are intentionally
split so that in the future we can have a declarative effects API create
overlays from within the same context. Similar to how one can
instantiate windows from a typical QML scene.
Notes:
I don't like how I pass the kwin GL context from the backends into the
effect, but I need something that works with the library separation. It
also currently has wayland problem if I create a QOpenGLContext before
the QPA is set up with a scene - but I don't have anything better?
I know for the EffectFrame we need an API to push things through the
effects stack to handle blur/invert etc. Will deal with that when we
port the EffectFrame.
Test Plan: Used in an effect
Reviewers: #kwin, zzag
Reviewed By: #kwin, zzag
Subscribers: zzag, kwin
Tags: #kwin
Differential Revision: https://phabricator.kde.org/D24215
2019-09-27 15:06:37 +00:00
|
|
|
kwineffectquickview.cpp
|
2019-09-17 09:15:35 +00:00
|
|
|
kwineffects.cpp
|
2015-07-31 10:07:53 +00:00
|
|
|
logging.cpp
|
2019-09-17 09:15:35 +00:00
|
|
|
)
|
2008-04-10 23:15:44 +00:00
|
|
|
|
2013-02-25 11:05:36 +00:00
|
|
|
set(kwineffects_QT_LIBS
|
2013-08-20 07:10:18 +00:00
|
|
|
Qt5::DBus
|
|
|
|
|
Qt5::Widgets
|
[libkwineffects] Introduce API to easily show a QtQuick scene in an effect
Summary:
EffectQuickView/Scene is a convenient class to render a QtQuick
scenegraph into an effect.
Current methods (such as present windows) involve creating an underlying
platform window which is expensive, causes a headache to filter out
again in the rest of the code, and only works as an overlay.
The new class exposes things more natively to an effect where we don't
mess with real windows, we can perform the painting anywhere in the view
and we don't have issues with hiding/closing.
QtQuick has both software and hardware accelerated modes, and kwin also
has 3 render backends. Every combination is supported.
* When used in OpenGL mode for both, we render into an FBO export the
texture ID then it's up to the effect to render that into a scene.
* When using software QtQuick rendering we blit into an image, upload
that into a KWinGLTexture which serves as an abstraction layer and
render that into the scene.
* When using GL for QtQuick and XRender/QPainter in kwin everything is
rendered into the internal FBO, blit and exported as an image.
* When using software rendering for both an image gets passed directly.
Mouse and keyboard events can be forwarded, only if the effect
intercepts them.
The class is meant to be generic enough that we can remove all the
QtQuick code from Aurorae.
The intention is also to replace EffectFrameImpl using this backend and
we can kill all of the EffectFrame code throughout the scenes.
The close button in present windows will also be ported to this,
simplifiying that code base.
Classes that handle the rendering and handling QML are intentionally
split so that in the future we can have a declarative effects API create
overlays from within the same context. Similar to how one can
instantiate windows from a typical QML scene.
Notes:
I don't like how I pass the kwin GL context from the backends into the
effect, but I need something that works with the library separation. It
also currently has wayland problem if I create a QOpenGLContext before
the QPA is set up with a scene - but I don't have anything better?
I know for the EffectFrame we need an API to push things through the
effects stack to handle blur/invert etc. Will deal with that when we
port the EffectFrame.
Test Plan: Used in an effect
Reviewers: #kwin, zzag
Reviewed By: #kwin, zzag
Subscribers: zzag, kwin
Tags: #kwin
Differential Revision: https://phabricator.kde.org/D24215
2019-09-27 15:06:37 +00:00
|
|
|
Qt5::Quick
|
2013-02-25 11:05:36 +00:00
|
|
|
)
|
|
|
|
|
|
|
|
|
|
set(kwineffects_KDE_LIBS
|
2013-12-11 20:41:47 +00:00
|
|
|
KF5::ConfigCore
|
2015-07-07 07:38:08 +00:00
|
|
|
KF5::CoreAddons
|
2014-03-18 13:38:00 +00:00
|
|
|
KF5::WindowSystem
|
[libkwineffects] Introduce API to easily show a QtQuick scene in an effect
Summary:
EffectQuickView/Scene is a convenient class to render a QtQuick
scenegraph into an effect.
Current methods (such as present windows) involve creating an underlying
platform window which is expensive, causes a headache to filter out
again in the rest of the code, and only works as an overlay.
The new class exposes things more natively to an effect where we don't
mess with real windows, we can perform the painting anywhere in the view
and we don't have issues with hiding/closing.
QtQuick has both software and hardware accelerated modes, and kwin also
has 3 render backends. Every combination is supported.
* When used in OpenGL mode for both, we render into an FBO export the
texture ID then it's up to the effect to render that into a scene.
* When using software QtQuick rendering we blit into an image, upload
that into a KWinGLTexture which serves as an abstraction layer and
render that into the scene.
* When using GL for QtQuick and XRender/QPainter in kwin everything is
rendered into the internal FBO, blit and exported as an image.
* When using software rendering for both an image gets passed directly.
Mouse and keyboard events can be forwarded, only if the effect
intercepts them.
The class is meant to be generic enough that we can remove all the
QtQuick code from Aurorae.
The intention is also to replace EffectFrameImpl using this backend and
we can kill all of the EffectFrame code throughout the scenes.
The close button in present windows will also be ported to this,
simplifiying that code base.
Classes that handle the rendering and handling QML are intentionally
split so that in the future we can have a declarative effects API create
overlays from within the same context. Similar to how one can
instantiate windows from a typical QML scene.
Notes:
I don't like how I pass the kwin GL context from the backends into the
effect, but I need something that works with the library separation. It
also currently has wayland problem if I create a QOpenGLContext before
the QPA is set up with a scene - but I don't have anything better?
I know for the EffectFrame we need an API to push things through the
effects stack to handle blur/invert etc. Will deal with that when we
port the EffectFrame.
Test Plan: Used in an effect
Reviewers: #kwin, zzag
Reviewed By: #kwin, zzag
Subscribers: zzag, kwin
Tags: #kwin
Differential Revision: https://phabricator.kde.org/D24215
2019-09-27 15:06:37 +00:00
|
|
|
KF5::Declarative
|
2013-02-25 11:05:36 +00:00
|
|
|
)
|
|
|
|
|
|
|
|
|
|
set(kwineffects_XCB_LIBS
|
2014-02-25 14:48:39 +00:00
|
|
|
XCB::XCB
|
2011-08-13 14:38:57 +00:00
|
|
|
)
|
2013-02-25 11:05:36 +00:00
|
|
|
|
2013-11-15 12:37:47 +00:00
|
|
|
add_library(kwineffects SHARED ${kwin_EFFECTSLIB_SRCS})
|
2013-12-01 19:45:39 +00:00
|
|
|
generate_export_header(kwineffects EXPORT_FILE_NAME kwineffects_export.h)
|
2013-02-25 11:05:36 +00:00
|
|
|
target_link_libraries(kwineffects
|
2019-09-17 09:15:35 +00:00
|
|
|
PUBLIC
|
|
|
|
|
${kwineffects_QT_LIBS}
|
|
|
|
|
${kwineffects_KDE_LIBS}
|
|
|
|
|
${kwineffects_XCB_LIBS}
|
[libkwineffects] Introduce API to easily show a QtQuick scene in an effect
Summary:
EffectQuickView/Scene is a convenient class to render a QtQuick
scenegraph into an effect.
Current methods (such as present windows) involve creating an underlying
platform window which is expensive, causes a headache to filter out
again in the rest of the code, and only works as an overlay.
The new class exposes things more natively to an effect where we don't
mess with real windows, we can perform the painting anywhere in the view
and we don't have issues with hiding/closing.
QtQuick has both software and hardware accelerated modes, and kwin also
has 3 render backends. Every combination is supported.
* When used in OpenGL mode for both, we render into an FBO export the
texture ID then it's up to the effect to render that into a scene.
* When using software QtQuick rendering we blit into an image, upload
that into a KWinGLTexture which serves as an abstraction layer and
render that into the scene.
* When using GL for QtQuick and XRender/QPainter in kwin everything is
rendered into the internal FBO, blit and exported as an image.
* When using software rendering for both an image gets passed directly.
Mouse and keyboard events can be forwarded, only if the effect
intercepts them.
The class is meant to be generic enough that we can remove all the
QtQuick code from Aurorae.
The intention is also to replace EffectFrameImpl using this backend and
we can kill all of the EffectFrame code throughout the scenes.
The close button in present windows will also be ported to this,
simplifiying that code base.
Classes that handle the rendering and handling QML are intentionally
split so that in the future we can have a declarative effects API create
overlays from within the same context. Similar to how one can
instantiate windows from a typical QML scene.
Notes:
I don't like how I pass the kwin GL context from the backends into the
effect, but I need something that works with the library separation. It
also currently has wayland problem if I create a QOpenGLContext before
the QPA is set up with a scene - but I don't have anything better?
I know for the EffectFrame we need an API to push things through the
effects stack to handle blur/invert etc. Will deal with that when we
port the EffectFrame.
Test Plan: Used in an effect
Reviewers: #kwin, zzag
Reviewed By: #kwin, zzag
Subscribers: zzag, kwin
Tags: #kwin
Differential Revision: https://phabricator.kde.org/D24215
2019-09-27 15:06:37 +00:00
|
|
|
kwinglutils
|
2013-02-25 11:05:36 +00:00
|
|
|
)
|
2019-09-17 09:15:35 +00:00
|
|
|
if (KWIN_HAVE_XRENDER_COMPOSITING)
|
2014-03-16 14:31:23 +00:00
|
|
|
target_link_libraries(kwineffects PRIVATE kwinxrenderutils XCB::XFIXES)
|
|
|
|
|
endif()
|
2014-05-07 11:54:36 +00:00
|
|
|
set_target_properties(kwineffects PROPERTIES
|
|
|
|
|
VERSION ${KWINEFFECTS_VERSION_STRING}
|
|
|
|
|
SOVERSION ${KWINEFFECTS_SOVERSION}
|
|
|
|
|
)
|
2012-03-16 07:37:09 +00:00
|
|
|
set_target_properties(kwineffects PROPERTIES OUTPUT_NAME ${KWIN_NAME}effects)
|
2008-04-10 23:15:44 +00:00
|
|
|
|
2008-12-09 21:27:30 +00:00
|
|
|
install(TARGETS kwineffects EXPORT kdeworkspaceLibraryTargets ${INSTALL_TARGETS_DEFAULT_ARGS})
|
2007-04-29 17:35:43 +00:00
|
|
|
|
2011-08-13 14:38:57 +00:00
|
|
|
# kwingl(es)utils library
|
|
|
|
|
set(kwin_GLUTILSLIB_SRCS
|
2019-09-17 09:15:35 +00:00
|
|
|
kwinglplatform.cpp
|
2011-08-13 14:38:57 +00:00
|
|
|
kwingltexture.cpp
|
2019-09-17 09:15:35 +00:00
|
|
|
kwinglutils.cpp
|
2011-08-13 14:38:57 +00:00
|
|
|
kwinglutils_funcs.cpp
|
2015-07-31 10:07:53 +00:00
|
|
|
logging.cpp
|
2019-09-17 09:15:35 +00:00
|
|
|
)
|
2011-07-17 14:15:07 +00:00
|
|
|
|
2019-09-17 09:15:35 +00:00
|
|
|
macro(KWIN4_ADD_GLUTILS_BACKEND name glinclude)
|
2011-08-13 14:38:57 +00:00
|
|
|
include_directories(${glinclude})
|
2013-11-15 12:37:47 +00:00
|
|
|
add_library(${name} SHARED ${kwin_GLUTILSLIB_SRCS})
|
2014-03-05 10:35:18 +00:00
|
|
|
generate_export_header(${name} BASE_NAME kwinglutils EXPORT_FILE_NAME kwinglutils_export.h)
|
2016-12-02 19:27:43 +00:00
|
|
|
target_link_libraries(${name} PUBLIC XCB::XCB KF5::CoreAddons KF5::ConfigCore KF5::WindowSystem)
|
2014-05-07 11:54:36 +00:00
|
|
|
set_target_properties(${name} PROPERTIES
|
|
|
|
|
VERSION ${KWINEFFECTS_VERSION_STRING}
|
|
|
|
|
SOVERSION ${KWINEFFECTS_SOVERSION}
|
|
|
|
|
)
|
2013-11-10 19:45:23 +00:00
|
|
|
target_link_libraries(${name} PUBLIC ${ARGN})
|
2011-07-17 14:15:07 +00:00
|
|
|
|
2011-08-13 14:38:57 +00:00
|
|
|
install(TARGETS ${name} EXPORT kdeworkspaceLibraryTargets ${INSTALL_TARGETS_DEFAULT_ARGS})
|
2013-02-25 10:44:26 +00:00
|
|
|
endmacro()
|
2011-07-17 14:15:07 +00:00
|
|
|
|
2015-10-30 12:47:37 +00:00
|
|
|
kwin4_add_glutils_backend(kwinglutils ${epoxy_INCLUDE_DIR} ${epoxy_LIBRARY})
|
|
|
|
|
set_target_properties(kwinglutils PROPERTIES OUTPUT_NAME ${KWIN_NAME}glutils)
|
|
|
|
|
|
|
|
|
|
target_link_libraries(kwinglutils PUBLIC ${epoxy_LIBRARY})
|
2007-04-29 17:35:43 +00:00
|
|
|
|
2019-09-17 09:15:35 +00:00
|
|
|
install(FILES
|
|
|
|
|
${CMAKE_CURRENT_BINARY_DIR}/kwinconfig.h
|
|
|
|
|
${CMAKE_CURRENT_BINARY_DIR}/kwineffects_export.h
|
|
|
|
|
${CMAKE_CURRENT_BINARY_DIR}/kwinglutils_export.h
|
|
|
|
|
${CMAKE_CURRENT_BINARY_DIR}/kwinxrenderutils_export.h
|
2011-10-19 23:04:52 +00:00
|
|
|
kwinanimationeffect.h
|
[libkwineffects] Introduce API to easily show a QtQuick scene in an effect
Summary:
EffectQuickView/Scene is a convenient class to render a QtQuick
scenegraph into an effect.
Current methods (such as present windows) involve creating an underlying
platform window which is expensive, causes a headache to filter out
again in the rest of the code, and only works as an overlay.
The new class exposes things more natively to an effect where we don't
mess with real windows, we can perform the painting anywhere in the view
and we don't have issues with hiding/closing.
QtQuick has both software and hardware accelerated modes, and kwin also
has 3 render backends. Every combination is supported.
* When used in OpenGL mode for both, we render into an FBO export the
texture ID then it's up to the effect to render that into a scene.
* When using software QtQuick rendering we blit into an image, upload
that into a KWinGLTexture which serves as an abstraction layer and
render that into the scene.
* When using GL for QtQuick and XRender/QPainter in kwin everything is
rendered into the internal FBO, blit and exported as an image.
* When using software rendering for both an image gets passed directly.
Mouse and keyboard events can be forwarded, only if the effect
intercepts them.
The class is meant to be generic enough that we can remove all the
QtQuick code from Aurorae.
The intention is also to replace EffectFrameImpl using this backend and
we can kill all of the EffectFrame code throughout the scenes.
The close button in present windows will also be ported to this,
simplifiying that code base.
Classes that handle the rendering and handling QML are intentionally
split so that in the future we can have a declarative effects API create
overlays from within the same context. Similar to how one can
instantiate windows from a typical QML scene.
Notes:
I don't like how I pass the kwin GL context from the backends into the
effect, but I need something that works with the library separation. It
also currently has wayland problem if I create a QOpenGLContext before
the QPA is set up with a scene - but I don't have anything better?
I know for the EffectFrame we need an API to push things through the
effects stack to handle blur/invert etc. Will deal with that when we
port the EffectFrame.
Test Plan: Used in an effect
Reviewers: #kwin, zzag
Reviewed By: #kwin, zzag
Subscribers: zzag, kwin
Tags: #kwin
Differential Revision: https://phabricator.kde.org/D24215
2019-09-27 15:06:37 +00:00
|
|
|
kwineffectquickview.h
|
2019-09-17 09:15:35 +00:00
|
|
|
kwineffects.h
|
|
|
|
|
kwinglobals.h
|
2011-02-19 08:58:44 +00:00
|
|
|
kwinglplatform.h
|
2019-09-17 09:15:35 +00:00
|
|
|
kwingltexture.h
|
2008-02-01 14:15:16 +00:00
|
|
|
kwinglutils.h
|
|
|
|
|
kwinglutils_funcs.h
|
2008-05-07 14:43:13 +00:00
|
|
|
kwinxrenderutils.h
|
2008-06-27 06:56:11 +00:00
|
|
|
DESTINATION ${INCLUDE_INSTALL_DIR} COMPONENT Devel)
|
