diff --git a/src/Makefile b/src/Makefile
index 89dd759aa..9fa01ed8a 100644
--- a/src/Makefile
+++ b/src/Makefile
@@ -469,6 +469,9 @@ ifeq ($(TARGET_PLATFORM),PLATFORM_DESKTOP_GLFW)
$(call wl_generate, $(WL_PROTOCOLS_DIR)/fractional-scale-v1.xml, fractional-scale-v1-client-protocol)
$(call wl_generate, $(WL_PROTOCOLS_DIR)/xdg-activation-v1.xml, xdg-activation-v1-client-protocol)
$(call wl_generate, $(WL_PROTOCOLS_DIR)/idle-inhibit-unstable-v1.xml, idle-inhibit-unstable-v1-client-protocol)
+
+ wlr_protocols_dir := $(shell pkg-config --variable=pkgdatadir wlr-protocols)
+ $(call wl_generate, $(wlr_protocols_dir)/unstable/wlr-layer-shell-unstable-v1.xml, wlr-layer-shell-unstable-v1-client-protocol)
endif
endif
endif
diff --git a/src/external/glfw/deps/wayland/wlr-layer-shell-unstable-v1.xml b/src/external/glfw/deps/wayland/wlr-layer-shell-unstable-v1.xml
new file mode 100644
index 000000000..e9f27e4fd
--- /dev/null
+++ b/src/external/glfw/deps/wayland/wlr-layer-shell-unstable-v1.xml
@@ -0,0 +1,407 @@
+
+
+
+ Copyright © 2017 Drew DeVault
+
+ Permission to use, copy, modify, distribute, and sell this
+ software and its documentation for any purpose is hereby granted
+ without fee, provided that the above copyright notice appear in
+ all copies and that both that copyright notice and this permission
+ notice appear in supporting documentation, and that the name of
+ the copyright holders not be used in advertising or publicity
+ pertaining to distribution of the software without specific,
+ written prior permission. The copyright holders make no
+ representations about the suitability of this software for any
+ purpose. It is provided "as is" without express or implied
+ warranty.
+
+ THE COPYRIGHT HOLDERS DISCLAIM ALL WARRANTIES WITH REGARD TO THIS
+ SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND
+ FITNESS, IN NO EVENT SHALL THE COPYRIGHT HOLDERS BE LIABLE FOR ANY
+ SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+ WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN
+ AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION,
+ ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF
+ THIS SOFTWARE.
+
+
+
+
+ Clients can use this interface to assign the surface_layer role to
+ wl_surfaces. Such surfaces are assigned to a "layer" of the output and
+ rendered with a defined z-depth respective to each other. They may also be
+ anchored to the edges and corners of a screen and specify input handling
+ semantics. This interface should be suitable for the implementation of
+ many desktop shell components, and a broad number of other applications
+ that interact with the desktop.
+
+
+
+
+ Create a layer surface for an existing surface. This assigns the role of
+ layer_surface, or raises a protocol error if another role is already
+ assigned.
+
+ Creating a layer surface from a wl_surface which has a buffer attached
+ or committed is a client error, and any attempts by a client to attach
+ or manipulate a buffer prior to the first layer_surface.configure call
+ must also be treated as errors.
+
+ After creating a layer_surface object and setting it up, the client
+ must perform an initial commit without any buffer attached.
+ The compositor will reply with a layer_surface.configure event.
+ The client must acknowledge it and is then allowed to attach a buffer
+ to map the surface.
+
+ You may pass NULL for output to allow the compositor to decide which
+ output to use. Generally this will be the one that the user most
+ recently interacted with.
+
+ Clients can specify a namespace that defines the purpose of the layer
+ surface.
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ These values indicate which layers a surface can be rendered in. They
+ are ordered by z depth, bottom-most first. Traditional shell surfaces
+ will typically be rendered between the bottom and top layers.
+ Fullscreen shell surfaces are typically rendered at the top layer.
+ Multiple surfaces can share a single layer, and ordering within a
+ single layer is undefined.
+
+
+
+
+
+
+
+
+
+
+
+
+ This request indicates that the client will not use the layer_shell
+ object any more. Objects that have been created through this instance
+ are not affected.
+
+
+
+
+
+
+ An interface that may be implemented by a wl_surface, for surfaces that
+ are designed to be rendered as a layer of a stacked desktop-like
+ environment.
+
+ Layer surface state (layer, size, anchor, exclusive zone,
+ margin, interactivity) is double-buffered, and will be applied at the
+ time wl_surface.commit of the corresponding wl_surface is called.
+
+ Attaching a null buffer to a layer surface unmaps it.
+
+ Unmapping a layer_surface means that the surface cannot be shown by the
+ compositor until it is explicitly mapped again. The layer_surface
+ returns to the state it had right after layer_shell.get_layer_surface.
+ The client can re-map the surface by performing a commit without any
+ buffer attached, waiting for a configure event and handling it as usual.
+
+
+
+
+ Sets the size of the surface in surface-local coordinates. The
+ compositor will display the surface centered with respect to its
+ anchors.
+
+ If you pass 0 for either value, the compositor will assign it and
+ inform you of the assignment in the configure event. You must set your
+ anchor to opposite edges in the dimensions you omit; not doing so is a
+ protocol error. Both values are 0 by default.
+
+ Size is double-buffered, see wl_surface.commit.
+
+
+
+
+
+
+
+ Requests that the compositor anchor the surface to the specified edges
+ and corners. If two orthogonal edges are specified (e.g. 'top' and
+ 'left'), then the anchor point will be the intersection of the edges
+ (e.g. the top left corner of the output); otherwise the anchor point
+ will be centered on that edge, or in the center if none is specified.
+
+ Anchor is double-buffered, see wl_surface.commit.
+
+
+
+
+
+
+ Requests that the compositor avoids occluding an area with other
+ surfaces. The compositor's use of this information is
+ implementation-dependent - do not assume that this region will not
+ actually be occluded.
+
+ A positive value is only meaningful if the surface is anchored to one
+ edge or an edge and both perpendicular edges. If the surface is not
+ anchored, anchored to only two perpendicular edges (a corner), anchored
+ to only two parallel edges or anchored to all edges, a positive value
+ will be treated the same as zero.
+
+ A positive zone is the distance from the edge in surface-local
+ coordinates to consider exclusive.
+
+ Surfaces that do not wish to have an exclusive zone may instead specify
+ how they should interact with surfaces that do. If set to zero, the
+ surface indicates that it would like to be moved to avoid occluding
+ surfaces with a positive exclusive zone. If set to -1, the surface
+ indicates that it would not like to be moved to accommodate for other
+ surfaces, and the compositor should extend it all the way to the edges
+ it is anchored to.
+
+ For example, a panel might set its exclusive zone to 10, so that
+ maximized shell surfaces are not shown on top of it. A notification
+ might set its exclusive zone to 0, so that it is moved to avoid
+ occluding the panel, but shell surfaces are shown underneath it. A
+ wallpaper or lock screen might set their exclusive zone to -1, so that
+ they stretch below or over the panel.
+
+ The default value is 0.
+
+ Exclusive zone is double-buffered, see wl_surface.commit.
+
+
+
+
+
+
+ Requests that the surface be placed some distance away from the anchor
+ point on the output, in surface-local coordinates. Setting this value
+ for edges you are not anchored to has no effect.
+
+ The exclusive zone includes the margin.
+
+ Margin is double-buffered, see wl_surface.commit.
+
+
+
+
+
+
+
+
+
+ Types of keyboard interaction possible for layer shell surfaces. The
+ rationale for this is twofold: (1) some applications are not interested
+ in keyboard events and not allowing them to be focused can improve the
+ desktop experience; (2) some applications will want to take exclusive
+ keyboard focus.
+
+
+
+
+ This value indicates that this surface is not interested in keyboard
+ events and the compositor should never assign it the keyboard focus.
+
+ This is the default value, set for newly created layer shell surfaces.
+
+ This is useful for e.g. desktop widgets that display information or
+ only have interaction with non-keyboard input devices.
+
+
+
+
+ Request exclusive keyboard focus if this surface is above the shell surface layer.
+
+ For the top and overlay layers, the seat will always give
+ exclusive keyboard focus to the top-most layer which has keyboard
+ interactivity set to exclusive. If this layer contains multiple
+ surfaces with keyboard interactivity set to exclusive, the compositor
+ determines the one receiving keyboard events in an implementation-
+ defined manner. In this case, no guarantee is made when this surface
+ will receive keyboard focus (if ever).
+
+ For the bottom and background layers, the compositor is allowed to use
+ normal focus semantics.
+
+ This setting is mainly intended for applications that need to ensure
+ they receive all keyboard events, such as a lock screen or a password
+ prompt.
+
+
+
+
+ This requests the compositor to allow this surface to be focused and
+ unfocused by the user in an implementation-defined manner. The user
+ should be able to unfocus this surface even regardless of the layer
+ it is on.
+
+ Typically, the compositor will want to use its normal mechanism to
+ manage keyboard focus between layer shell surfaces with this setting
+ and regular toplevels on the desktop layer (e.g. click to focus).
+ Nevertheless, it is possible for a compositor to require a special
+ interaction to focus or unfocus layer shell surfaces (e.g. requiring
+ a click even if focus follows the mouse normally, or providing a
+ keybinding to switch focus between layers).
+
+ This setting is mainly intended for desktop shell components (e.g.
+ panels) that allow keyboard interaction. Using this option can allow
+ implementing a desktop shell that can be fully usable without the
+ mouse.
+
+
+
+
+
+
+ Set how keyboard events are delivered to this surface. By default,
+ layer shell surfaces do not receive keyboard events; this request can
+ be used to change this.
+
+ This setting is inherited by child surfaces set by the get_popup
+ request.
+
+ Layer surfaces receive pointer, touch, and tablet events normally. If
+ you do not want to receive them, set the input region on your surface
+ to an empty region.
+
+ Keyboard interactivity is double-buffered, see wl_surface.commit.
+
+
+
+
+
+
+ This assigns an xdg_popup's parent to this layer_surface. This popup
+ should have been created via xdg_surface::get_popup with the parent set
+ to NULL, and this request must be invoked before committing the popup's
+ initial state.
+
+ See the documentation of xdg_popup for more details about what an
+ xdg_popup is and how it is used.
+
+
+
+
+
+
+ When a configure event is received, if a client commits the
+ surface in response to the configure event, then the client
+ must make an ack_configure request sometime before the commit
+ request, passing along the serial of the configure event.
+
+ If the client receives multiple configure events before it
+ can respond to one, it only has to ack the last configure event.
+
+ A client is not required to commit immediately after sending
+ an ack_configure request - it may even ack_configure several times
+ before its next surface commit.
+
+ A client may send multiple ack_configure requests before committing, but
+ only the last request sent before a commit indicates which configure
+ event the client really is responding to.
+
+
+
+
+
+
+ This request destroys the layer surface.
+
+
+
+
+
+ The configure event asks the client to resize its surface.
+
+ Clients should arrange their surface for the new states, and then send
+ an ack_configure request with the serial sent in this configure event at
+ some point before committing the new surface.
+
+ The client is free to dismiss all but the last configure event it
+ received.
+
+ The width and height arguments specify the size of the window in
+ surface-local coordinates.
+
+ The size is a hint, in the sense that the client is free to ignore it if
+ it doesn't resize, pick a smaller size (to satisfy aspect ratio or
+ resize in steps of NxM pixels). If the client picks a smaller size and
+ is anchored to two opposite anchors (e.g. 'top' and 'bottom'), the
+ surface will be centered on this axis.
+
+ If the width or height arguments are zero, it means the client should
+ decide its own window dimension.
+
+
+
+
+
+
+
+
+ The closed event is sent by the compositor when the surface will no
+ longer be shown. The output may have been destroyed or the user may
+ have asked for it to be removed. Further changes to the surface will be
+ ignored. The client should destroy the resource after receiving this
+ event, and create a new surface if they so choose.
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Change the layer that the surface is rendered on.
+
+ Layer is double-buffered, see wl_surface.commit.
+
+
+
+
+
+
+
+
+ Requests an edge for the exclusive zone to apply. The exclusive
+ edge will be automatically deduced from anchor points when possible,
+ but when the surface is anchored to a corner, it will be necessary
+ to set it explicitly to disambiguate, as it is not possible to deduce
+ which one of the two corner edges should be used.
+
+ The edge must be one the surface is anchored to, otherwise the
+ invalid_exclusive_edge protocol error will be raised.
+
+
+
+
+
diff --git a/src/external/glfw/include/GLFW/glfw3.h b/src/external/glfw/include/GLFW/glfw3.h
index 9c55ac9d9..fe2169ad0 100644
--- a/src/external/glfw/include/GLFW/glfw3.h
+++ b/src/external/glfw/include/GLFW/glfw3.h
@@ -1135,6 +1135,7 @@ extern "C" {
* Allows specification of the Wayland app_id.
*/
#define GLFW_WAYLAND_APP_ID 0x00026001
+#define GLFW_WAYLAND_LAYER_SHELL 0x00026002
/*! @} */
#define GLFW_NO_API 0
diff --git a/src/external/glfw/src/CMakeLists.txt b/src/external/glfw/src/CMakeLists.txt
index 1057a6f98..e4f97573c 100644
--- a/src/external/glfw/src/CMakeLists.txt
+++ b/src/external/glfw/src/CMakeLists.txt
@@ -104,6 +104,7 @@ if (GLFW_BUILD_WAYLAND)
generate_wayland_protocol("fractional-scale-v1.xml")
generate_wayland_protocol("xdg-activation-v1.xml")
generate_wayland_protocol("xdg-decoration-unstable-v1.xml")
+ generate_wayland_protocol("wlr-layer-shell-unstable-v1.xml")
endif()
if (WIN32 AND GLFW_BUILD_SHARED_LIBRARY)
diff --git a/src/external/glfw/src/internal.h b/src/external/glfw/src/internal.h
index 887335935..9da3d708e 100644
--- a/src/external/glfw/src/internal.h
+++ b/src/external/glfw/src/internal.h
@@ -419,6 +419,7 @@ struct _GLFWwndconfig
} win32;
struct {
char appId[256];
+ int layerShellLayer;
} wl;
};
diff --git a/src/external/glfw/src/window.c b/src/external/glfw/src/window.c
index 1463d1694..cff5f442e 100644
--- a/src/external/glfw/src/window.c
+++ b/src/external/glfw/src/window.c
@@ -276,6 +276,7 @@ void glfwDefaultWindowHints(void)
_glfw.hints.window.xpos = GLFW_ANY_POSITION;
_glfw.hints.window.ypos = GLFW_ANY_POSITION;
_glfw.hints.window.scaleFramebuffer = GLFW_TRUE;
+ _glfw.hints.window.wl.layerShellLayer = -1;
// The default is 24 bits of color, 24 bits of depth and 8 bits of stencil,
// double buffered
@@ -431,6 +432,9 @@ GLFWAPI void glfwWindowHint(int hint, int value)
case GLFW_REFRESH_RATE:
_glfw.hints.refreshRate = value;
return;
+ case GLFW_WAYLAND_LAYER_SHELL:
+ _glfw.hints.window.wl.layerShellLayer = value;
+ return;
}
_glfwInputError(GLFW_INVALID_ENUM, "Invalid window hint 0x%08X", hint);
diff --git a/src/external/glfw/src/wl_init.c b/src/external/glfw/src/wl_init.c
index 2428c725e..7a8a77a61 100644
--- a/src/external/glfw/src/wl_init.c
+++ b/src/external/glfw/src/wl_init.c
@@ -50,6 +50,7 @@
#include "fractional-scale-v1-client-protocol.h"
#include "xdg-activation-v1-client-protocol.h"
#include "idle-inhibit-unstable-v1-client-protocol.h"
+#include "wlr-layer-shell-unstable-v1-client-protocol.h"
// NOTE: Versions of wayland-scanner prior to 1.17.91 named every global array of
// wl_interface pointers 'types', making it impossible to combine several unmodified
@@ -155,6 +156,10 @@ static void registryHandleGlobal(void* userData,
wl_registry_bind(registry, name, &xdg_wm_base_interface, 1);
xdg_wm_base_add_listener(_glfw.wl.wmBase, &wmBaseListener, NULL);
}
+ else if (strcmp(interface, "zwlr_layer_shell_v1") == 0)
+ {
+ _glfw.wl.layerShell = wl_registry_bind(registry, name, &zwlr_layer_shell_v1_interface, 1);
+ }
else if (strcmp(interface, "zxdg_decoration_manager_v1") == 0)
{
_glfw.wl.decorationManager =
@@ -952,6 +957,8 @@ void _glfwTerminateWayland(void)
wl_compositor_destroy(_glfw.wl.compositor);
if (_glfw.wl.shm)
wl_shm_destroy(_glfw.wl.shm);
+ if (_glfw.wl.layerShell)
+ zwlr_layer_shell_v1_destroy(_glfw.wl.layerShell);
if (_glfw.wl.viewporter)
wp_viewporter_destroy(_glfw.wl.viewporter);
if (_glfw.wl.decorationManager)
diff --git a/src/external/glfw/src/wl_platform.h b/src/external/glfw/src/wl_platform.h
index 149cd241b..803ab11d9 100644
--- a/src/external/glfw/src/wl_platform.h
+++ b/src/external/glfw/src/wl_platform.h
@@ -380,6 +380,11 @@ typedef struct _GLFWwindowWayland
uint32_t decorationMode;
} xdg;
+ struct {
+ struct zwlr_layer_surface_v1* surface;
+ int layer;
+ } layerShell;
+
struct {
struct libdecor_frame* frame;
} libdecor;
@@ -436,6 +441,7 @@ typedef struct _GLFWlibraryWayland
struct zwp_pointer_constraints_v1* pointerConstraints;
struct zwp_idle_inhibit_manager_v1* idleInhibitManager;
struct xdg_activation_v1* activationManager;
+ struct zwlr_layer_shell_v1* layerShell;
struct wp_fractional_scale_manager_v1* fractionalScaleManager;
_GLFWofferWayland* offers;
diff --git a/src/external/glfw/src/wl_window.c b/src/external/glfw/src/wl_window.c
index 505166eff..77155c33a 100644
--- a/src/external/glfw/src/wl_window.c
+++ b/src/external/glfw/src/wl_window.c
@@ -50,6 +50,8 @@
#include "relative-pointer-unstable-v1-client-protocol.h"
#include "pointer-constraints-unstable-v1-client-protocol.h"
#include "xdg-activation-v1-client-protocol.h"
+#include "wlr-layer-shell-unstable-v1-client-protocol.h"
+#include "wlr-layer-shell-unstable-v1-client-protocol-code.h"
#include "idle-inhibit-unstable-v1-client-protocol.h"
#include "fractional-scale-v1-client-protocol.h"
@@ -688,6 +690,45 @@ static const struct xdg_surface_listener xdgSurfaceListener =
xdgSurfaceHandleConfigure
};
+static void layerSurfaceHandleConfigure(void* userData,
+ struct zwlr_layer_surface_v1* surface,
+ uint32_t serial,
+ uint32_t width,
+ uint32_t height)
+{
+ _GLFWwindow* window = userData;
+
+ zwlr_layer_surface_v1_ack_configure(surface, serial);
+
+ if (width > 0 && height > 0)
+ {
+ window->wl.width = width;
+ window->wl.height = height;
+ window->wl.fbWidth = width;
+ window->wl.fbHeight = height;
+
+ resizeFramebuffer(window);
+ _glfwInputFramebufferSize(window, window->wl.fbWidth, window->wl.fbHeight);
+ _glfwInputWindowSize(window, window->wl.width, window->wl.height);
+ }
+
+ window->wl.visible = GLFW_TRUE;
+ _glfwInputWindowFocus(window, GLFW_TRUE);
+}
+
+static void layerSurfaceHandleClosed(void* userData,
+ struct zwlr_layer_surface_v1* surface)
+{
+ _GLFWwindow* window = userData;
+ _glfwInputWindowCloseRequest(window);
+}
+
+static const struct zwlr_layer_surface_v1_listener layerSurfaceListener =
+{
+ layerSurfaceHandleConfigure,
+ layerSurfaceHandleClosed
+};
+
void libdecorFrameHandleConfigure(struct libdecor_frame* frame,
struct libdecor_configuration* config,
void* userData)
@@ -913,6 +954,43 @@ static void updateXdgSizeLimits(_GLFWwindow* window)
xdg_toplevel_set_max_size(window->wl.xdg.toplevel, maxwidth, maxheight);
}
+static GLFWbool createLayerShellSurface(_GLFWwindow* window)
+{
+ window->wl.layerShell.surface = zwlr_layer_shell_v1_get_layer_surface(
+ _glfw.wl.layerShell,
+ window->wl.surface,
+ NULL,
+ window->wl.layerShell.layer, // Use the stored layer value
+ window->wl.appId ? window->wl.appId : "glfw-layer");
+
+ if (!window->wl.layerShell.surface)
+ {
+ _glfwInputError(GLFW_PLATFORM_ERROR,
+ "Wayland: Failed to create layer surface");
+ return GLFW_FALSE;
+ }
+
+ // Fullscreen on all edges
+ zwlr_layer_surface_v1_set_size(window->wl.layerShell.surface, 0, 0);
+ zwlr_layer_surface_v1_set_anchor(window->wl.layerShell.surface,
+ ZWLR_LAYER_SURFACE_V1_ANCHOR_TOP |
+ ZWLR_LAYER_SURFACE_V1_ANCHOR_BOTTOM |
+ ZWLR_LAYER_SURFACE_V1_ANCHOR_LEFT |
+ ZWLR_LAYER_SURFACE_V1_ANCHOR_RIGHT);
+ zwlr_layer_surface_v1_set_exclusive_zone(window->wl.layerShell.surface, -1);
+ zwlr_layer_surface_v1_set_keyboard_interactivity(
+ window->wl.layerShell.surface,
+ ZWLR_LAYER_SURFACE_V1_KEYBOARD_INTERACTIVITY_EXCLUSIVE);
+
+ zwlr_layer_surface_v1_add_listener(window->wl.layerShell.surface,
+ &layerSurfaceListener, window);
+
+ wl_surface_commit(window->wl.surface);
+ wl_display_roundtrip(_glfw.wl.display);
+
+ return GLFW_TRUE;
+}
+
static GLFWbool createXdgShellObjects(_GLFWwindow* window)
{
window->wl.xdg.surface = xdg_wm_base_get_xdg_surface(_glfw.wl.wmBase,
@@ -987,6 +1065,9 @@ static GLFWbool createXdgShellObjects(_GLFWwindow* window)
static GLFWbool createShellObjects(_GLFWwindow* window)
{
+ if (window->wl.layerShell.layer >= 0 && _glfw.wl.layerShell)
+ return createLayerShellSurface(window);
+
if (_glfw.wl.libdecor.context)
{
if (createLibdecorFrame(window))
@@ -996,6 +1077,7 @@ static GLFWbool createShellObjects(_GLFWwindow* window)
return createXdgShellObjects(window);
}
+
static void destroyShellObjects(_GLFWwindow* window)
{
destroyFallbackDecorations(window);
@@ -1003,6 +1085,12 @@ static void destroyShellObjects(_GLFWwindow* window)
if (window->wl.libdecor.frame)
libdecor_frame_unref(window->wl.libdecor.frame);
+ if (window->wl.layerShell.surface)
+ {
+ zwlr_layer_surface_v1_destroy(window->wl.layerShell.surface);
+ window->wl.layerShell.surface = NULL;
+ }
+
if (window->wl.xdg.decoration)
zxdg_toplevel_decoration_v1_destroy(window->wl.xdg.decoration);
@@ -1040,6 +1128,7 @@ static GLFWbool createNativeSurface(_GLFWwindow* window,
window->wl.fbWidth = wndconfig->width;
window->wl.fbHeight = wndconfig->height;
window->wl.appId = _glfw_strdup(wndconfig->wl.appId);
+ window->wl.layerShell.layer = wndconfig->wl.layerShellLayer;
window->wl.bufferScale = 1;
window->wl.scalingNumerator = 120;
@@ -3306,4 +3395,3 @@ GLFWAPI struct wl_surface* glfwGetWaylandWindow(GLFWwindow* handle)
}
#endif // _GLFW_WAYLAND
-
diff --git a/src/platforms/rcore_desktop_glfw.c b/src/platforms/rcore_desktop_glfw.c
index 84b021573..0ad37b6a9 100644
--- a/src/platforms/rcore_desktop_glfw.c
+++ b/src/platforms/rcore_desktop_glfw.c
@@ -1471,6 +1471,16 @@ int InitPlatform(void)
#endif
}
+ // Wayland layer shell
+ if (FLAG_IS_SET(CORE.Window.flags, FLAG_WAYLAND_LAYER_OVERLAY))
+ glfwWindowHint(GLFW_WAYLAND_LAYER_SHELL, 3); // ZWLR_LAYER_SHELL_V1_LAYER_OVERLAY
+ else if (FLAG_IS_SET(CORE.Window.flags, FLAG_WAYLAND_LAYER_TOP))
+ glfwWindowHint(GLFW_WAYLAND_LAYER_SHELL, 2); // ZWLR_LAYER_SHELL_V1_LAYER_TOP
+ else if (FLAG_IS_SET(CORE.Window.flags, FLAG_WAYLAND_LAYER_BOTTOM))
+ glfwWindowHint(GLFW_WAYLAND_LAYER_SHELL, 1); // ZWLR_LAYER_SHELL_V1_LAYER_BOTTOM
+ else if (FLAG_IS_SET(CORE.Window.flags, FLAG_WAYLAND_LAYER_BACKGROUND))
+ glfwWindowHint(GLFW_WAYLAND_LAYER_SHELL, 0); // ZWLR_LAYER_SHELL_V1_LAYER_BACKGROUND
+
// Mouse passthrough
if (FLAG_IS_SET(CORE.Window.flags, FLAG_WINDOW_MOUSE_PASSTHROUGH)) glfwWindowHint(GLFW_MOUSE_PASSTHROUGH, GLFW_TRUE);
else glfwWindowHint(GLFW_MOUSE_PASSTHROUGH, GLFW_FALSE);
diff --git a/src/raylib.h b/src/raylib.h
index 2d411f896..51e6d67bf 100644
--- a/src/raylib.h
+++ b/src/raylib.h
@@ -553,7 +553,12 @@ typedef enum {
FLAG_WINDOW_MOUSE_PASSTHROUGH = 0x00004000, // Set to support mouse passthrough, only supported when FLAG_WINDOW_UNDECORATED
FLAG_BORDERLESS_WINDOWED_MODE = 0x00008000, // Set to run program in borderless windowed mode
FLAG_MSAA_4X_HINT = 0x00000020, // Set to try enabling MSAA 4X
- FLAG_INTERLACED_HINT = 0x00010000 // Set to try enabling interlaced video format (for V3D)
+ FLAG_INTERLACED_HINT = 0x00010000, // Set to try enabling interlaced video format (for V3D)
+
+ FLAG_WAYLAND_LAYER_BACKGROUND = 0x00020000, // Layer 0
+ FLAG_WAYLAND_LAYER_BOTTOM = 0x00040000, // Layer 1
+ FLAG_WAYLAND_LAYER_TOP = 0x00080000, // Layer 2
+ FLAG_WAYLAND_LAYER_OVERLAY = 0x00100000, // Layer 3
} ConfigFlags;
// Trace log level
diff --git a/src/wlr-layer-shell-unstable-v1-client-protocol.c b/src/wlr-layer-shell-unstable-v1-client-protocol.c
new file mode 100644
index 000000000..0d5fa3136
--- /dev/null
+++ b/src/wlr-layer-shell-unstable-v1-client-protocol.c
@@ -0,0 +1,94 @@
+/* Generated by wayland-scanner 1.24.0 */
+
+/*
+ * Copyright © 2017 Drew DeVault
+ *
+ * Permission to use, copy, modify, distribute, and sell this
+ * software and its documentation for any purpose is hereby granted
+ * without fee, provided that the above copyright notice appear in
+ * all copies and that both that copyright notice and this permission
+ * notice appear in supporting documentation, and that the name of
+ * the copyright holders not be used in advertising or publicity
+ * pertaining to distribution of the software without specific,
+ * written prior permission. The copyright holders make no
+ * representations about the suitability of this software for any
+ * purpose. It is provided "as is" without express or implied
+ * warranty.
+ *
+ * THE COPYRIGHT HOLDERS DISCLAIM ALL WARRANTIES WITH REGARD TO THIS
+ * SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND
+ * FITNESS, IN NO EVENT SHALL THE COPYRIGHT HOLDERS BE LIABLE FOR ANY
+ * SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+ * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN
+ * AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION,
+ * ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF
+ * THIS SOFTWARE.
+ */
+
+#include
+#include
+#include
+#include "wayland-util.h"
+
+#ifndef __has_attribute
+# define __has_attribute(x) 0 /* Compatibility with non-clang compilers. */
+#endif
+
+#if (__has_attribute(visibility) || defined(__GNUC__) && __GNUC__ >= 4)
+#define WL_PRIVATE __attribute__ ((visibility("hidden")))
+#else
+#define WL_PRIVATE
+#endif
+
+extern const struct wl_interface wl_output_interface;
+extern const struct wl_interface wl_surface_interface;
+extern const struct wl_interface xdg_popup_interface;
+extern const struct wl_interface zwlr_layer_surface_v1_interface;
+
+static const struct wl_interface *wlr_layer_shell_unstable_v1_types[] = {
+ NULL,
+ NULL,
+ NULL,
+ NULL,
+ &zwlr_layer_surface_v1_interface,
+ &wl_surface_interface,
+ &wl_output_interface,
+ NULL,
+ NULL,
+ &xdg_popup_interface,
+};
+
+static const struct wl_message zwlr_layer_shell_v1_requests[] = {
+ { "get_layer_surface", "no?ous", wlr_layer_shell_unstable_v1_types + 4 },
+ { "destroy", "3", wlr_layer_shell_unstable_v1_types + 0 },
+};
+
+WL_PRIVATE const struct wl_interface zwlr_layer_shell_v1_interface = {
+ "zwlr_layer_shell_v1", 4,
+ 2, zwlr_layer_shell_v1_requests,
+ 0, NULL,
+};
+
+static const struct wl_message zwlr_layer_surface_v1_requests[] = {
+ { "set_size", "uu", wlr_layer_shell_unstable_v1_types + 0 },
+ { "set_anchor", "u", wlr_layer_shell_unstable_v1_types + 0 },
+ { "set_exclusive_zone", "i", wlr_layer_shell_unstable_v1_types + 0 },
+ { "set_margin", "iiii", wlr_layer_shell_unstable_v1_types + 0 },
+ { "set_keyboard_interactivity", "u", wlr_layer_shell_unstable_v1_types + 0 },
+ { "get_popup", "o", wlr_layer_shell_unstable_v1_types + 9 },
+ { "ack_configure", "u", wlr_layer_shell_unstable_v1_types + 0 },
+ { "destroy", "", wlr_layer_shell_unstable_v1_types + 0 },
+ { "set_layer", "2u", wlr_layer_shell_unstable_v1_types + 0 },
+};
+
+static const struct wl_message zwlr_layer_surface_v1_events[] = {
+ { "configure", "uuu", wlr_layer_shell_unstable_v1_types + 0 },
+ { "closed", "", wlr_layer_shell_unstable_v1_types + 0 },
+};
+
+WL_PRIVATE const struct wl_interface zwlr_layer_surface_v1_interface = {
+ "zwlr_layer_surface_v1", 4,
+ 9, zwlr_layer_surface_v1_requests,
+ 2, zwlr_layer_surface_v1_events,
+};
+