1414 lines
42 KiB
C++
1414 lines
42 KiB
C++
/**************************************************************************/
|
|
/* display_server_wayland.cpp */
|
|
/**************************************************************************/
|
|
/* This file is part of: */
|
|
/* GODOT ENGINE */
|
|
/* https://godotengine.org */
|
|
/**************************************************************************/
|
|
/* Copyright (c) 2014-present Godot Engine contributors (see AUTHORS.md). */
|
|
/* Copyright (c) 2007-2014 Juan Linietsky, Ariel Manzur. */
|
|
/* */
|
|
/* Permission is hereby granted, free of charge, to any person obtaining */
|
|
/* a copy of this software and associated documentation files (the */
|
|
/* "Software"), to deal in the Software without restriction, including */
|
|
/* without limitation the rights to use, copy, modify, merge, publish, */
|
|
/* distribute, sublicense, and/or sell copies of the Software, and to */
|
|
/* permit persons to whom the Software is furnished to do so, subject to */
|
|
/* the following conditions: */
|
|
/* */
|
|
/* The above copyright notice and this permission notice shall be */
|
|
/* included in all copies or substantial portions of the Software. */
|
|
/* */
|
|
/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, */
|
|
/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF */
|
|
/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. */
|
|
/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY */
|
|
/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, */
|
|
/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE */
|
|
/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */
|
|
/**************************************************************************/
|
|
|
|
#include "display_server_wayland.h"
|
|
|
|
#ifdef WAYLAND_ENABLED
|
|
|
|
#define WAYLAND_DISPLAY_SERVER_DEBUG_LOGS_ENABLED
|
|
#ifdef WAYLAND_DISPLAY_SERVER_DEBUG_LOGS_ENABLED
|
|
#define DEBUG_LOG_WAYLAND(...) print_verbose(__VA_ARGS__)
|
|
#else
|
|
#define DEBUG_LOG_WAYLAND(...)
|
|
#endif
|
|
|
|
#ifdef VULKAN_ENABLED
|
|
#include "servers/rendering/renderer_rd/renderer_compositor_rd.h"
|
|
#endif
|
|
|
|
#ifdef GLES3_ENABLED
|
|
#include "detect_prime_egl.h"
|
|
#include "drivers/gles3/rasterizer_gles3.h"
|
|
#endif
|
|
|
|
String DisplayServerWayland::_get_app_id_from_context(Context p_context) {
|
|
String app_id;
|
|
|
|
switch (p_context) {
|
|
case CONTEXT_EDITOR: {
|
|
app_id = "org.godotengine.Editor";
|
|
} break;
|
|
|
|
case CONTEXT_PROJECTMAN: {
|
|
app_id = "org.godotengine.ProjectManager";
|
|
} break;
|
|
|
|
case CONTEXT_ENGINE:
|
|
default: {
|
|
String config_name = GLOBAL_GET("application/config/name");
|
|
if (config_name.length() != 0) {
|
|
app_id = config_name;
|
|
} else {
|
|
app_id = "org.godotengine.Godot";
|
|
}
|
|
}
|
|
}
|
|
|
|
return app_id;
|
|
}
|
|
|
|
void DisplayServerWayland::_send_window_event(WindowEvent p_event) {
|
|
WindowData &wd = main_window;
|
|
|
|
if (wd.window_event_callback.is_valid()) {
|
|
Variant event = int(p_event);
|
|
wd.window_event_callback.call(event);
|
|
}
|
|
}
|
|
|
|
void DisplayServerWayland::dispatch_input_events(const Ref<InputEvent> &p_event) {
|
|
((DisplayServerWayland *)(get_singleton()))->_dispatch_input_event(p_event);
|
|
}
|
|
|
|
void DisplayServerWayland::_dispatch_input_event(const Ref<InputEvent> &p_event) {
|
|
Callable callable = main_window.input_event_callback;
|
|
if (callable.is_valid()) {
|
|
callable.call(p_event);
|
|
}
|
|
}
|
|
|
|
void DisplayServerWayland::_resize_window(const Size2i &p_size) {
|
|
WindowData &wd = main_window;
|
|
|
|
wd.rect.size = p_size;
|
|
|
|
#ifdef RD_ENABLED
|
|
if (wd.visible && rendering_context) {
|
|
rendering_context->window_set_size(MAIN_WINDOW_ID, wd.rect.size.width, wd.rect.size.height);
|
|
}
|
|
#endif
|
|
|
|
#ifdef GLES3_ENABLED
|
|
if (wd.visible && egl_manager) {
|
|
wl_egl_window_resize(wd.wl_egl_window, wd.rect.size.width, wd.rect.size.height, 0, 0);
|
|
}
|
|
#endif
|
|
|
|
if (wd.rect_changed_callback.is_valid()) {
|
|
wd.rect_changed_callback.call(wd.rect);
|
|
}
|
|
}
|
|
|
|
void DisplayServerWayland::_show_window() {
|
|
MutexLock mutex_lock(wayland_thread.mutex);
|
|
|
|
WindowData &wd = main_window;
|
|
|
|
if (!wd.visible) {
|
|
DEBUG_LOG_WAYLAND("Showing window.");
|
|
|
|
// Showing this window will reset its mode with whatever the compositor
|
|
// reports. We'll save the mode beforehand so that we can reapply it later.
|
|
// TODO: Fix/Port/Move/Whatever to `WaylandThread` APIs.
|
|
WindowMode setup_mode = wd.mode;
|
|
|
|
wayland_thread.window_create(MAIN_WINDOW_ID, wd.rect.size.width, wd.rect.size.height);
|
|
wayland_thread.window_set_min_size(MAIN_WINDOW_ID, wd.min_size);
|
|
wayland_thread.window_set_max_size(MAIN_WINDOW_ID, wd.max_size);
|
|
wayland_thread.window_set_app_id(MAIN_WINDOW_ID, _get_app_id_from_context(context));
|
|
wayland_thread.window_set_borderless(MAIN_WINDOW_ID, window_get_flag(WINDOW_FLAG_BORDERLESS));
|
|
|
|
// NOTE: The XDG shell protocol is built in a way that causes the window to
|
|
// be immediately shown as soon as a valid buffer is assigned to it. Hence,
|
|
// the only acceptable way of implementing window showing is to move the
|
|
// graphics context window creation logic here.
|
|
#ifdef RD_ENABLED
|
|
if (rendering_context) {
|
|
union {
|
|
#ifdef VULKAN_ENABLED
|
|
RenderingContextDriverVulkanWayland::WindowPlatformData vulkan;
|
|
#endif
|
|
} wpd;
|
|
#ifdef VULKAN_ENABLED
|
|
if (rendering_driver == "vulkan") {
|
|
wpd.vulkan.surface = wayland_thread.window_get_wl_surface(wd.id);
|
|
wpd.vulkan.display = wayland_thread.get_wl_display();
|
|
}
|
|
#endif
|
|
Error err = rendering_context->window_create(wd.id, &wpd);
|
|
ERR_FAIL_COND_MSG(err != OK, vformat("Can't create a %s window", rendering_driver));
|
|
|
|
rendering_context->window_set_size(wd.id, wd.rect.size.width, wd.rect.size.height);
|
|
rendering_context->window_set_vsync_mode(wd.id, wd.vsync_mode);
|
|
|
|
emulate_vsync = (rendering_context->window_get_vsync_mode(wd.id) == DisplayServer::VSYNC_ENABLED);
|
|
|
|
if (emulate_vsync) {
|
|
print_verbose("VSYNC: manually throttling frames using MAILBOX.");
|
|
rendering_context->window_set_vsync_mode(wd.id, DisplayServer::VSYNC_MAILBOX);
|
|
}
|
|
}
|
|
#endif
|
|
|
|
#ifdef GLES3_ENABLED
|
|
if (egl_manager) {
|
|
struct wl_surface *wl_surface = wayland_thread.window_get_wl_surface(wd.id);
|
|
wd.wl_egl_window = wl_egl_window_create(wl_surface, wd.rect.size.width, wd.rect.size.height);
|
|
|
|
Error err = egl_manager->window_create(MAIN_WINDOW_ID, wayland_thread.get_wl_display(), wd.wl_egl_window, wd.rect.size.width, wd.rect.size.height);
|
|
ERR_FAIL_COND_MSG(err == ERR_CANT_CREATE, "Can't show a GLES3 window.");
|
|
|
|
window_set_vsync_mode(wd.vsync_mode, MAIN_WINDOW_ID);
|
|
}
|
|
#endif
|
|
// NOTE: The public window-handling methods might depend on this flag being
|
|
// set. Ensure to not make any of these calls before this assignment.
|
|
wd.visible = true;
|
|
|
|
// Actually try to apply the window's mode now that it's visible.
|
|
window_set_mode(setup_mode);
|
|
|
|
wayland_thread.window_set_title(MAIN_WINDOW_ID, wd.title);
|
|
}
|
|
}
|
|
// Interface methods.
|
|
|
|
bool DisplayServerWayland::has_feature(Feature p_feature) const {
|
|
switch (p_feature) {
|
|
case FEATURE_MOUSE:
|
|
case FEATURE_CLIPBOARD:
|
|
case FEATURE_CURSOR_SHAPE:
|
|
case FEATURE_WINDOW_TRANSPARENCY:
|
|
case FEATURE_SWAP_BUFFERS:
|
|
case FEATURE_KEEP_SCREEN_ON:
|
|
case FEATURE_CLIPBOARD_PRIMARY:
|
|
#ifdef DBUS_ENABLED
|
|
case FEATURE_NATIVE_DIALOG:
|
|
#endif
|
|
case FEATURE_HIDPI: {
|
|
return true;
|
|
} break;
|
|
|
|
default: {
|
|
return false;
|
|
}
|
|
}
|
|
}
|
|
|
|
String DisplayServerWayland::get_name() const {
|
|
return "Wayland";
|
|
}
|
|
|
|
#ifdef SPEECHD_ENABLED
|
|
|
|
bool DisplayServerWayland::tts_is_speaking() const {
|
|
ERR_FAIL_NULL_V(tts, false);
|
|
return tts->is_speaking();
|
|
}
|
|
|
|
bool DisplayServerWayland::tts_is_paused() const {
|
|
ERR_FAIL_NULL_V(tts, false);
|
|
return tts->is_paused();
|
|
}
|
|
|
|
TypedArray<Dictionary> DisplayServerWayland::tts_get_voices() const {
|
|
ERR_FAIL_NULL_V(tts, TypedArray<Dictionary>());
|
|
return tts->get_voices();
|
|
}
|
|
|
|
void DisplayServerWayland::tts_speak(const String &p_text, const String &p_voice, int p_volume, float p_pitch, float p_rate, int p_utterance_id, bool p_interrupt) {
|
|
ERR_FAIL_NULL(tts);
|
|
tts->speak(p_text, p_voice, p_volume, p_pitch, p_rate, p_utterance_id, p_interrupt);
|
|
}
|
|
|
|
void DisplayServerWayland::tts_pause() {
|
|
ERR_FAIL_NULL(tts);
|
|
tts->pause();
|
|
}
|
|
|
|
void DisplayServerWayland::tts_resume() {
|
|
ERR_FAIL_NULL(tts);
|
|
tts->resume();
|
|
}
|
|
|
|
void DisplayServerWayland::tts_stop() {
|
|
ERR_FAIL_NULL(tts);
|
|
tts->stop();
|
|
}
|
|
|
|
#endif
|
|
|
|
#ifdef DBUS_ENABLED
|
|
|
|
bool DisplayServerWayland::is_dark_mode_supported() const {
|
|
return portal_desktop->is_supported();
|
|
}
|
|
|
|
bool DisplayServerWayland::is_dark_mode() const {
|
|
switch (portal_desktop->get_appearance_color_scheme()) {
|
|
case 1:
|
|
// Prefers dark theme.
|
|
return true;
|
|
case 2:
|
|
// Prefers light theme.
|
|
return false;
|
|
default:
|
|
// Preference unknown.
|
|
return false;
|
|
}
|
|
}
|
|
|
|
void DisplayServerWayland::set_system_theme_change_callback(const Callable &p_callable) {
|
|
portal_desktop->set_system_theme_change_callback(p_callable);
|
|
}
|
|
|
|
Error DisplayServerWayland::file_dialog_show(const String &p_title, const String &p_current_directory, const String &p_filename, bool p_show_hidden, FileDialogMode p_mode, const Vector<String> &p_filters, const Callable &p_callback) {
|
|
WindowID window_id = MAIN_WINDOW_ID;
|
|
// TODO: Use window IDs for multiwindow support.
|
|
|
|
WaylandThread::WindowState *ws = wayland_thread.wl_surface_get_window_state(wayland_thread.window_get_wl_surface(window_id));
|
|
return portal_desktop->file_dialog_show(window_id, (ws ? ws->exported_handle : String()), p_title, p_current_directory, String(), p_filename, p_mode, p_filters, TypedArray<Dictionary>(), p_callback, false);
|
|
}
|
|
|
|
Error DisplayServerWayland::file_dialog_with_options_show(const String &p_title, const String &p_current_directory, const String &p_root, const String &p_filename, bool p_show_hidden, FileDialogMode p_mode, const Vector<String> &p_filters, const TypedArray<Dictionary> &p_options, const Callable &p_callback) {
|
|
WindowID window_id = MAIN_WINDOW_ID;
|
|
// TODO: Use window IDs for multiwindow support.
|
|
|
|
WaylandThread::WindowState *ws = wayland_thread.wl_surface_get_window_state(wayland_thread.window_get_wl_surface(window_id));
|
|
return portal_desktop->file_dialog_show(window_id, (ws ? ws->exported_handle : String()), p_title, p_current_directory, p_root, p_filename, p_mode, p_filters, p_options, p_callback, true);
|
|
}
|
|
|
|
#endif
|
|
|
|
void DisplayServerWayland::mouse_set_mode(MouseMode p_mode) {
|
|
if (p_mode == mouse_mode) {
|
|
return;
|
|
}
|
|
|
|
MutexLock mutex_lock(wayland_thread.mutex);
|
|
|
|
bool show_cursor = (p_mode == MOUSE_MODE_VISIBLE || p_mode == MOUSE_MODE_CONFINED);
|
|
|
|
if (show_cursor) {
|
|
if (custom_cursors.has(cursor_shape)) {
|
|
wayland_thread.cursor_set_custom_shape(cursor_shape);
|
|
} else {
|
|
wayland_thread.cursor_set_shape(cursor_shape);
|
|
}
|
|
} else {
|
|
wayland_thread.cursor_hide();
|
|
}
|
|
|
|
WaylandThread::PointerConstraint constraint = WaylandThread::PointerConstraint::NONE;
|
|
|
|
switch (p_mode) {
|
|
case DisplayServer::MOUSE_MODE_CAPTURED: {
|
|
constraint = WaylandThread::PointerConstraint::LOCKED;
|
|
} break;
|
|
|
|
case DisplayServer::MOUSE_MODE_CONFINED:
|
|
case DisplayServer::MOUSE_MODE_CONFINED_HIDDEN: {
|
|
constraint = WaylandThread::PointerConstraint::CONFINED;
|
|
} break;
|
|
|
|
default: {
|
|
}
|
|
}
|
|
|
|
wayland_thread.pointer_set_constraint(constraint);
|
|
|
|
mouse_mode = p_mode;
|
|
}
|
|
|
|
DisplayServerWayland::MouseMode DisplayServerWayland::mouse_get_mode() const {
|
|
return mouse_mode;
|
|
}
|
|
|
|
// NOTE: This is hacked together (and not guaranteed to work in the first place)
|
|
// as for some reason the there's no proper way to ask the compositor to warp
|
|
// the pointer, although, at the time of writing, there's a proposal for a
|
|
// proper protocol for this. See:
|
|
// https://gitlab.freedesktop.org/wayland/wayland-protocols/-/issues/158
|
|
void DisplayServerWayland::warp_mouse(const Point2i &p_to) {
|
|
MutexLock mutex_lock(wayland_thread.mutex);
|
|
|
|
WaylandThread::PointerConstraint old_constraint = wayland_thread.pointer_get_constraint();
|
|
|
|
wayland_thread.pointer_set_constraint(WaylandThread::PointerConstraint::LOCKED);
|
|
wayland_thread.pointer_set_hint(p_to);
|
|
|
|
wayland_thread.pointer_set_constraint(old_constraint);
|
|
}
|
|
|
|
Point2i DisplayServerWayland::mouse_get_position() const {
|
|
MutexLock mutex_lock(wayland_thread.mutex);
|
|
|
|
// We can't properly implement this method by design.
|
|
// This is the best we can do unfortunately.
|
|
return Input::get_singleton()->get_mouse_position();
|
|
|
|
return Point2i();
|
|
}
|
|
|
|
BitField<MouseButtonMask> DisplayServerWayland::mouse_get_button_state() const {
|
|
MutexLock mutex_lock(wayland_thread.mutex);
|
|
|
|
// Are we sure this is the only way? This seems sus.
|
|
// TODO: Handle tablets properly.
|
|
//mouse_button_mask.set_flag(MouseButtonMask((int64_t)wls.current_seat->tablet_tool_data.pressed_button_mask));
|
|
|
|
return wayland_thread.pointer_get_button_mask();
|
|
}
|
|
|
|
// NOTE: According to the Wayland specification, this method will only do
|
|
// anything if the user has interacted with the application by sending a
|
|
// "recent enough" input event.
|
|
// TODO: Add this limitation to the documentation.
|
|
void DisplayServerWayland::clipboard_set(const String &p_text) {
|
|
MutexLock mutex_lock(wayland_thread.mutex);
|
|
|
|
wayland_thread.selection_set_text(p_text);
|
|
}
|
|
|
|
String DisplayServerWayland::clipboard_get() const {
|
|
MutexLock mutex_lock(wayland_thread.mutex);
|
|
|
|
Vector<uint8_t> data;
|
|
|
|
const String text_mimes[] = {
|
|
"text/plain;charset=utf-8",
|
|
"text/plain",
|
|
};
|
|
|
|
for (String mime : text_mimes) {
|
|
if (wayland_thread.selection_has_mime(mime)) {
|
|
print_verbose(vformat("Selecting media type \"%s\" from offered types.", mime));
|
|
data = wayland_thread.selection_get_mime(mime);
|
|
break;
|
|
}
|
|
}
|
|
|
|
return String::utf8((const char *)data.ptr(), data.size());
|
|
}
|
|
|
|
Ref<Image> DisplayServerWayland::clipboard_get_image() const {
|
|
MutexLock mutex_lock(wayland_thread.mutex);
|
|
|
|
Ref<Image> image;
|
|
image.instantiate();
|
|
|
|
Error err = OK;
|
|
|
|
// TODO: Fallback to next media type on missing module or parse error.
|
|
if (wayland_thread.selection_has_mime("image/png")) {
|
|
err = image->load_png_from_buffer(wayland_thread.selection_get_mime("image/png"));
|
|
} else if (wayland_thread.selection_has_mime("image/jpeg")) {
|
|
err = image->load_jpg_from_buffer(wayland_thread.selection_get_mime("image/jpeg"));
|
|
} else if (wayland_thread.selection_has_mime("image/webp")) {
|
|
err = image->load_webp_from_buffer(wayland_thread.selection_get_mime("image/webp"));
|
|
} else if (wayland_thread.selection_has_mime("image/svg+xml")) {
|
|
err = image->load_svg_from_buffer(wayland_thread.selection_get_mime("image/svg+xml"));
|
|
} else if (wayland_thread.selection_has_mime("image/bmp")) {
|
|
err = image->load_bmp_from_buffer(wayland_thread.selection_get_mime("image/bmp"));
|
|
} else if (wayland_thread.selection_has_mime("image/x-tga")) {
|
|
err = image->load_tga_from_buffer(wayland_thread.selection_get_mime("image/x-tga"));
|
|
} else if (wayland_thread.selection_has_mime("image/x-targa")) {
|
|
err = image->load_tga_from_buffer(wayland_thread.selection_get_mime("image/x-targa"));
|
|
} else if (wayland_thread.selection_has_mime("image/ktx")) {
|
|
err = image->load_ktx_from_buffer(wayland_thread.selection_get_mime("image/ktx"));
|
|
}
|
|
|
|
ERR_FAIL_COND_V(err != OK, Ref<Image>());
|
|
|
|
return image;
|
|
}
|
|
|
|
void DisplayServerWayland::clipboard_set_primary(const String &p_text) {
|
|
MutexLock mutex_lock(wayland_thread.mutex);
|
|
|
|
wayland_thread.primary_set_text(p_text);
|
|
}
|
|
|
|
String DisplayServerWayland::clipboard_get_primary() const {
|
|
MutexLock mutex_lock(wayland_thread.mutex);
|
|
|
|
Vector<uint8_t> data;
|
|
|
|
const String text_mimes[] = {
|
|
"text/plain;charset=utf-8",
|
|
"text/plain",
|
|
};
|
|
|
|
for (String mime : text_mimes) {
|
|
if (wayland_thread.primary_has_mime(mime)) {
|
|
print_verbose(vformat("Selecting media type \"%s\" from offered types.", mime));
|
|
wayland_thread.primary_get_mime(mime);
|
|
break;
|
|
}
|
|
}
|
|
|
|
return String::utf8((const char *)data.ptr(), data.size());
|
|
}
|
|
|
|
int DisplayServerWayland::get_screen_count() const {
|
|
MutexLock mutex_lock(wayland_thread.mutex);
|
|
return wayland_thread.get_screen_count();
|
|
}
|
|
|
|
int DisplayServerWayland::get_primary_screen() const {
|
|
// AFAIK Wayland doesn't allow knowing (nor we care) about which screen is
|
|
// primary.
|
|
return 0;
|
|
}
|
|
|
|
Point2i DisplayServerWayland::screen_get_position(int p_screen) const {
|
|
MutexLock mutex_lock(wayland_thread.mutex);
|
|
|
|
if (p_screen == SCREEN_OF_MAIN_WINDOW) {
|
|
p_screen = window_get_current_screen();
|
|
}
|
|
|
|
return wayland_thread.screen_get_data(p_screen).position;
|
|
}
|
|
|
|
Size2i DisplayServerWayland::screen_get_size(int p_screen) const {
|
|
MutexLock mutex_lock(wayland_thread.mutex);
|
|
|
|
if (p_screen == SCREEN_OF_MAIN_WINDOW) {
|
|
p_screen = window_get_current_screen();
|
|
}
|
|
|
|
return wayland_thread.screen_get_data(p_screen).size;
|
|
}
|
|
|
|
Rect2i DisplayServerWayland::screen_get_usable_rect(int p_screen) const {
|
|
// Unsupported on wayland.
|
|
return Rect2i(Point2i(), screen_get_size(p_screen));
|
|
}
|
|
|
|
int DisplayServerWayland::screen_get_dpi(int p_screen) const {
|
|
MutexLock mutex_lock(wayland_thread.mutex);
|
|
|
|
if (p_screen == SCREEN_OF_MAIN_WINDOW) {
|
|
p_screen = window_get_current_screen();
|
|
}
|
|
|
|
const WaylandThread::ScreenData &data = wayland_thread.screen_get_data(p_screen);
|
|
|
|
int width_mm = data.physical_size.width;
|
|
int height_mm = data.physical_size.height;
|
|
|
|
double xdpi = (width_mm ? data.size.width / (double)width_mm * 25.4 : 0);
|
|
double ydpi = (height_mm ? data.size.height / (double)height_mm * 25.4 : 0);
|
|
|
|
if (xdpi || ydpi) {
|
|
return (xdpi + ydpi) / (xdpi && ydpi ? 2 : 1);
|
|
}
|
|
|
|
// Could not get DPI.
|
|
return 96;
|
|
}
|
|
|
|
float DisplayServerWayland::screen_get_scale(int p_screen) const {
|
|
MutexLock mutex_lock(wayland_thread.mutex);
|
|
|
|
if (p_screen == SCREEN_OF_MAIN_WINDOW) {
|
|
p_screen = window_get_current_screen();
|
|
}
|
|
|
|
return wayland_thread.screen_get_data(p_screen).scale;
|
|
}
|
|
|
|
float DisplayServerWayland::screen_get_refresh_rate(int p_screen) const {
|
|
MutexLock mutex_lock(wayland_thread.mutex);
|
|
|
|
if (p_screen == SCREEN_OF_MAIN_WINDOW) {
|
|
p_screen = window_get_current_screen();
|
|
}
|
|
|
|
return wayland_thread.screen_get_data(p_screen).refresh_rate;
|
|
}
|
|
|
|
void DisplayServerWayland::screen_set_keep_on(bool p_enable) {
|
|
MutexLock mutex_lock(wayland_thread.mutex);
|
|
|
|
if (screen_is_kept_on() == p_enable) {
|
|
return;
|
|
}
|
|
|
|
#ifdef DBUS_ENABLED
|
|
if (screensaver) {
|
|
if (p_enable) {
|
|
screensaver->inhibit();
|
|
} else {
|
|
screensaver->uninhibit();
|
|
}
|
|
|
|
screensaver_inhibited = p_enable;
|
|
}
|
|
#endif
|
|
}
|
|
|
|
bool DisplayServerWayland::screen_is_kept_on() const {
|
|
#ifdef DBUS_ENABLED
|
|
return wayland_thread.window_get_idle_inhibition(MAIN_WINDOW_ID) || screensaver_inhibited;
|
|
#endif
|
|
|
|
return wayland_thread.window_get_idle_inhibition(MAIN_WINDOW_ID);
|
|
}
|
|
|
|
Vector<DisplayServer::WindowID> DisplayServerWayland::get_window_list() const {
|
|
MutexLock mutex_lock(wayland_thread.mutex);
|
|
|
|
Vector<int> ret;
|
|
ret.push_back(MAIN_WINDOW_ID);
|
|
|
|
return ret;
|
|
}
|
|
|
|
int64_t DisplayServerWayland::window_get_native_handle(HandleType p_handle_type, WindowID p_window) const {
|
|
MutexLock mutex_lock(wayland_thread.mutex);
|
|
|
|
switch (p_handle_type) {
|
|
case DISPLAY_HANDLE: {
|
|
return (int64_t)wayland_thread.get_wl_display();
|
|
} break;
|
|
|
|
case WINDOW_HANDLE: {
|
|
return (int64_t)wayland_thread.window_get_wl_surface(p_window);
|
|
} break;
|
|
|
|
case WINDOW_VIEW: {
|
|
return 0; // Not supported.
|
|
} break;
|
|
|
|
#ifdef GLES3_ENABLED
|
|
case OPENGL_CONTEXT: {
|
|
if (egl_manager) {
|
|
return (int64_t)egl_manager->get_context(p_window);
|
|
}
|
|
return 0;
|
|
} break;
|
|
#endif // GLES3_ENABLED
|
|
|
|
default: {
|
|
return 0;
|
|
} break;
|
|
}
|
|
}
|
|
|
|
DisplayServer::WindowID DisplayServerWayland::get_window_at_screen_position(const Point2i &p_position) const {
|
|
// Standard Wayland APIs don't support this.
|
|
return MAIN_WINDOW_ID;
|
|
}
|
|
|
|
void DisplayServerWayland::window_attach_instance_id(ObjectID p_instance, WindowID p_window_id) {
|
|
MutexLock mutex_lock(wayland_thread.mutex);
|
|
|
|
main_window.instance_id = p_instance;
|
|
}
|
|
|
|
ObjectID DisplayServerWayland::window_get_attached_instance_id(WindowID p_window_id) const {
|
|
MutexLock mutex_lock(wayland_thread.mutex);
|
|
|
|
return main_window.instance_id;
|
|
}
|
|
|
|
void DisplayServerWayland::window_set_title(const String &p_title, DisplayServer::WindowID p_window_id) {
|
|
MutexLock mutex_lock(wayland_thread.mutex);
|
|
|
|
WindowData &wd = main_window;
|
|
|
|
wd.title = p_title;
|
|
|
|
wayland_thread.window_set_title(MAIN_WINDOW_ID, wd.title);
|
|
}
|
|
|
|
void DisplayServerWayland::window_set_mouse_passthrough(const Vector<Vector2> &p_region, DisplayServer::WindowID p_window_id) {
|
|
// TODO
|
|
DEBUG_LOG_WAYLAND(vformat("wayland stub window_set_mouse_passthrough region %s", p_region));
|
|
}
|
|
|
|
void DisplayServerWayland::window_set_rect_changed_callback(const Callable &p_callable, DisplayServer::WindowID p_window_id) {
|
|
MutexLock mutex_lock(wayland_thread.mutex);
|
|
|
|
main_window.rect_changed_callback = p_callable;
|
|
}
|
|
|
|
void DisplayServerWayland::window_set_window_event_callback(const Callable &p_callable, DisplayServer::WindowID p_window_id) {
|
|
MutexLock mutex_lock(wayland_thread.mutex);
|
|
|
|
main_window.window_event_callback = p_callable;
|
|
}
|
|
|
|
void DisplayServerWayland::window_set_input_event_callback(const Callable &p_callable, DisplayServer::WindowID p_window_id) {
|
|
MutexLock mutex_lock(wayland_thread.mutex);
|
|
|
|
main_window.input_event_callback = p_callable;
|
|
}
|
|
|
|
void DisplayServerWayland::window_set_input_text_callback(const Callable &p_callable, WindowID p_window_id) {
|
|
MutexLock mutex_lock(wayland_thread.mutex);
|
|
|
|
main_window.input_text_callback = p_callable;
|
|
}
|
|
|
|
void DisplayServerWayland::window_set_drop_files_callback(const Callable &p_callable, DisplayServer::WindowID p_window_id) {
|
|
MutexLock mutex_lock(wayland_thread.mutex);
|
|
|
|
main_window.drop_files_callback = p_callable;
|
|
}
|
|
|
|
int DisplayServerWayland::window_get_current_screen(DisplayServer::WindowID p_window_id) const {
|
|
// Standard Wayland APIs don't support getting the screen of a window.
|
|
return 0;
|
|
}
|
|
|
|
void DisplayServerWayland::window_set_current_screen(int p_screen, DisplayServer::WindowID p_window_id) {
|
|
// Standard Wayland APIs don't support setting the screen of a window.
|
|
}
|
|
|
|
Point2i DisplayServerWayland::window_get_position(DisplayServer::WindowID p_window_id) const {
|
|
MutexLock mutex_lock(wayland_thread.mutex);
|
|
|
|
// We can't know the position of toplevels with the standard protocol.
|
|
return Point2i();
|
|
}
|
|
|
|
Point2i DisplayServerWayland::window_get_position_with_decorations(DisplayServer::WindowID p_window_id) const {
|
|
MutexLock mutex_lock(wayland_thread.mutex);
|
|
|
|
// We can't know the position of toplevels with the standard protocol, nor can
|
|
// we get information about the decorations, at least with SSDs.
|
|
return Point2i();
|
|
}
|
|
|
|
void DisplayServerWayland::window_set_position(const Point2i &p_position, DisplayServer::WindowID p_window_id) {
|
|
// Unsupported with toplevels.
|
|
}
|
|
|
|
void DisplayServerWayland::window_set_max_size(const Size2i p_size, DisplayServer::WindowID p_window_id) {
|
|
MutexLock mutex_lock(wayland_thread.mutex);
|
|
|
|
DEBUG_LOG_WAYLAND(vformat("window max size set to %s", p_size));
|
|
|
|
if (p_size.x < 0 || p_size.y < 0) {
|
|
ERR_FAIL_MSG("Maximum window size can't be negative!");
|
|
}
|
|
|
|
WindowData &wd = main_window;
|
|
|
|
// FIXME: Is `p_size.x < wd.min_size.x || p_size.y < wd.min_size.y` == `p_size < wd.min_size`?
|
|
if ((p_size != Size2i()) && ((p_size.x < wd.min_size.x) || (p_size.y < wd.min_size.y))) {
|
|
ERR_PRINT("Maximum window size can't be smaller than minimum window size!");
|
|
return;
|
|
}
|
|
|
|
wd.max_size = p_size;
|
|
|
|
wayland_thread.window_set_max_size(MAIN_WINDOW_ID, p_size);
|
|
}
|
|
|
|
Size2i DisplayServerWayland::window_get_max_size(DisplayServer::WindowID p_window_id) const {
|
|
MutexLock mutex_lock(wayland_thread.mutex);
|
|
|
|
return main_window.max_size;
|
|
}
|
|
|
|
void DisplayServerWayland::gl_window_make_current(DisplayServer::WindowID p_window_id) {
|
|
#ifdef GLES3_ENABLED
|
|
if (egl_manager) {
|
|
egl_manager->window_make_current(MAIN_WINDOW_ID);
|
|
}
|
|
#endif
|
|
}
|
|
|
|
void DisplayServerWayland::window_set_transient(WindowID p_window_id, WindowID p_parent) {
|
|
// Currently unsupported.
|
|
}
|
|
|
|
void DisplayServerWayland::window_set_min_size(const Size2i p_size, DisplayServer::WindowID p_window_id) {
|
|
MutexLock mutex_lock(wayland_thread.mutex);
|
|
|
|
DEBUG_LOG_WAYLAND(vformat("window minsize set to %s", p_size));
|
|
|
|
WindowData &wd = main_window;
|
|
|
|
if (p_size.x < 0 || p_size.y < 0) {
|
|
ERR_FAIL_MSG("Minimum window size can't be negative!");
|
|
}
|
|
|
|
// FIXME: Is `p_size.x > wd.max_size.x || p_size.y > wd.max_size.y` == `p_size > wd.max_size`?
|
|
if ((p_size != Size2i()) && (wd.max_size != Size2i()) && ((p_size.x > wd.max_size.x) || (p_size.y > wd.max_size.y))) {
|
|
ERR_PRINT("Minimum window size can't be larger than maximum window size!");
|
|
return;
|
|
}
|
|
|
|
wd.min_size = p_size;
|
|
|
|
wayland_thread.window_set_min_size(MAIN_WINDOW_ID, p_size);
|
|
}
|
|
|
|
Size2i DisplayServerWayland::window_get_min_size(DisplayServer::WindowID p_window_id) const {
|
|
MutexLock mutex_lock(wayland_thread.mutex);
|
|
|
|
return main_window.min_size;
|
|
}
|
|
|
|
void DisplayServerWayland::window_set_size(const Size2i p_size, DisplayServer::WindowID p_window_id) {
|
|
// The XDG spec doesn't allow non-interactive resizes.
|
|
}
|
|
|
|
Size2i DisplayServerWayland::window_get_size(DisplayServer::WindowID p_window_id) const {
|
|
MutexLock mutex_lock(wayland_thread.mutex);
|
|
|
|
return main_window.rect.size;
|
|
}
|
|
|
|
Size2i DisplayServerWayland::window_get_size_with_decorations(DisplayServer::WindowID p_window_id) const {
|
|
MutexLock mutex_lock(wayland_thread.mutex);
|
|
|
|
// I don't think there's a way of actually knowing the size of the window
|
|
// decoration in Wayland, at least in the case of SSDs, nor that it would be
|
|
// that useful in this case. We'll just return the main window's size.
|
|
return main_window.rect.size;
|
|
}
|
|
|
|
void DisplayServerWayland::window_set_mode(WindowMode p_mode, DisplayServer::WindowID p_window_id) {
|
|
MutexLock mutex_lock(wayland_thread.mutex);
|
|
|
|
WindowData &wd = main_window;
|
|
|
|
if (!wd.visible) {
|
|
return;
|
|
}
|
|
|
|
wayland_thread.window_try_set_mode(p_window_id, p_mode);
|
|
}
|
|
|
|
DisplayServer::WindowMode DisplayServerWayland::window_get_mode(DisplayServer::WindowID p_window_id) const {
|
|
MutexLock mutex_lock(wayland_thread.mutex);
|
|
|
|
const WindowData &wd = main_window;
|
|
|
|
if (!wd.visible) {
|
|
return WINDOW_MODE_WINDOWED;
|
|
}
|
|
|
|
return wayland_thread.window_get_mode(p_window_id);
|
|
}
|
|
|
|
bool DisplayServerWayland::window_is_maximize_allowed(DisplayServer::WindowID p_window_id) const {
|
|
MutexLock mutex_lock(wayland_thread.mutex);
|
|
|
|
return wayland_thread.window_can_set_mode(p_window_id, WINDOW_MODE_MAXIMIZED);
|
|
}
|
|
|
|
void DisplayServerWayland::window_set_flag(WindowFlags p_flag, bool p_enabled, DisplayServer::WindowID p_window_id) {
|
|
MutexLock mutex_lock(wayland_thread.mutex);
|
|
|
|
WindowData &wd = main_window;
|
|
|
|
DEBUG_LOG_WAYLAND(vformat("Window set flag %d", p_flag));
|
|
|
|
switch (p_flag) {
|
|
case WINDOW_FLAG_BORDERLESS: {
|
|
wayland_thread.window_set_borderless(MAIN_WINDOW_ID, p_enabled);
|
|
} break;
|
|
|
|
default: {
|
|
}
|
|
}
|
|
|
|
if (p_enabled) {
|
|
wd.flags |= 1 << p_flag;
|
|
} else {
|
|
wd.flags &= ~(1 << p_flag);
|
|
}
|
|
}
|
|
|
|
bool DisplayServerWayland::window_get_flag(WindowFlags p_flag, DisplayServer::WindowID p_window_id) const {
|
|
MutexLock mutex_lock(wayland_thread.mutex);
|
|
|
|
return main_window.flags & (1 << p_flag);
|
|
}
|
|
|
|
void DisplayServerWayland::window_request_attention(DisplayServer::WindowID p_window_id) {
|
|
MutexLock mutex_lock(wayland_thread.mutex);
|
|
|
|
DEBUG_LOG_WAYLAND("Requested attention.");
|
|
|
|
wayland_thread.window_request_attention(MAIN_WINDOW_ID);
|
|
}
|
|
|
|
void DisplayServerWayland::window_move_to_foreground(DisplayServer::WindowID p_window_id) {
|
|
// Standard Wayland APIs don't support this.
|
|
}
|
|
|
|
bool DisplayServerWayland::window_is_focused(WindowID p_window_id) const {
|
|
return wayland_thread.pointer_get_pointed_window_id() == p_window_id;
|
|
}
|
|
|
|
bool DisplayServerWayland::window_can_draw(DisplayServer::WindowID p_window_id) const {
|
|
return !suspended;
|
|
}
|
|
|
|
bool DisplayServerWayland::can_any_window_draw() const {
|
|
return !suspended;
|
|
}
|
|
|
|
void DisplayServerWayland::window_set_ime_active(const bool p_active, DisplayServer::WindowID p_window_id) {
|
|
// TODO
|
|
DEBUG_LOG_WAYLAND(vformat("wayland stub window_set_ime_active active %s", p_active ? "true" : "false"));
|
|
}
|
|
|
|
void DisplayServerWayland::window_set_ime_position(const Point2i &p_pos, DisplayServer::WindowID p_window_id) {
|
|
// TODO
|
|
DEBUG_LOG_WAYLAND(vformat("wayland stub window_set_ime_position pos %s window %d", p_pos, p_window_id));
|
|
}
|
|
|
|
// NOTE: While Wayland is supposed to be tear-free, wayland-protocols version
|
|
// 1.30 added a protocol for allowing async flips which is supposed to be
|
|
// handled by drivers such as Vulkan. We can then just ask to disable v-sync and
|
|
// hope for the best. See: https://gitlab.freedesktop.org/wayland/wayland-protocols/-/commit/6394f0b4f3be151076f10a845a2fb131eeb56706
|
|
void DisplayServerWayland::window_set_vsync_mode(DisplayServer::VSyncMode p_vsync_mode, DisplayServer::WindowID p_window_id) {
|
|
MutexLock mutex_lock(wayland_thread.mutex);
|
|
|
|
#ifdef RD_ENABLED
|
|
if (rendering_context) {
|
|
rendering_context->window_set_vsync_mode(p_window_id, p_vsync_mode);
|
|
|
|
emulate_vsync = (rendering_context->window_get_vsync_mode(p_window_id) == DisplayServer::VSYNC_ENABLED);
|
|
|
|
if (emulate_vsync) {
|
|
print_verbose("VSYNC: manually throttling frames using MAILBOX.");
|
|
rendering_context->window_set_vsync_mode(p_window_id, DisplayServer::VSYNC_MAILBOX);
|
|
}
|
|
}
|
|
#endif // VULKAN_ENABLED
|
|
|
|
#ifdef GLES3_ENABLED
|
|
if (egl_manager) {
|
|
egl_manager->set_use_vsync(p_vsync_mode != DisplayServer::VSYNC_DISABLED);
|
|
|
|
emulate_vsync = egl_manager->is_using_vsync();
|
|
|
|
if (emulate_vsync) {
|
|
print_verbose("VSYNC: manually throttling frames with swap delay 0.");
|
|
egl_manager->set_use_vsync(false);
|
|
}
|
|
}
|
|
#endif // GLES3_ENABLED
|
|
}
|
|
|
|
DisplayServer::VSyncMode DisplayServerWayland::window_get_vsync_mode(DisplayServer::WindowID p_window_id) const {
|
|
if (emulate_vsync) {
|
|
return DisplayServer::VSYNC_ENABLED;
|
|
}
|
|
|
|
#ifdef VULKAN_ENABLED
|
|
if (rendering_context) {
|
|
return rendering_context->window_get_vsync_mode(p_window_id);
|
|
}
|
|
#endif // VULKAN_ENABLED
|
|
|
|
#ifdef GLES3_ENABLED
|
|
if (egl_manager) {
|
|
return egl_manager->is_using_vsync() ? DisplayServer::VSYNC_ENABLED : DisplayServer::VSYNC_DISABLED;
|
|
}
|
|
#endif // GLES3_ENABLED
|
|
|
|
return DisplayServer::VSYNC_ENABLED;
|
|
}
|
|
|
|
void DisplayServerWayland::cursor_set_shape(CursorShape p_shape) {
|
|
ERR_FAIL_INDEX(p_shape, CURSOR_MAX);
|
|
|
|
MutexLock mutex_lock(wayland_thread.mutex);
|
|
|
|
if (p_shape == cursor_shape) {
|
|
return;
|
|
}
|
|
|
|
cursor_shape = p_shape;
|
|
|
|
if (mouse_mode != MOUSE_MODE_VISIBLE && mouse_mode != MOUSE_MODE_CONFINED) {
|
|
// Hidden.
|
|
return;
|
|
}
|
|
|
|
if (custom_cursors.has(p_shape)) {
|
|
wayland_thread.cursor_set_custom_shape(p_shape);
|
|
} else {
|
|
wayland_thread.cursor_set_shape(p_shape);
|
|
}
|
|
}
|
|
|
|
DisplayServerWayland::CursorShape DisplayServerWayland::cursor_get_shape() const {
|
|
MutexLock mutex_lock(wayland_thread.mutex);
|
|
|
|
return cursor_shape;
|
|
}
|
|
|
|
void DisplayServerWayland::cursor_set_custom_image(const Ref<Resource> &p_cursor, CursorShape p_shape, const Vector2 &p_hotspot) {
|
|
MutexLock mutex_lock(wayland_thread.mutex);
|
|
|
|
bool visible = (mouse_mode == MOUSE_MODE_VISIBLE || mouse_mode == MOUSE_MODE_CONFINED);
|
|
|
|
if (p_cursor.is_valid()) {
|
|
HashMap<CursorShape, CustomCursor>::Iterator cursor_c = custom_cursors.find(p_shape);
|
|
|
|
if (cursor_c) {
|
|
if (cursor_c->value.rid == p_cursor->get_rid() && cursor_c->value.hotspot == p_hotspot) {
|
|
// We have a cached cursor. Nice.
|
|
if (visible) {
|
|
wayland_thread.cursor_set_custom_shape(p_shape);
|
|
}
|
|
|
|
return;
|
|
}
|
|
|
|
// We're changing this cursor; we'll have to rebuild it.
|
|
custom_cursors.erase(p_shape);
|
|
wayland_thread.cursor_shape_clear_custom_image(p_shape);
|
|
}
|
|
|
|
Rect2 atlas_rect;
|
|
Ref<Image> image = _get_cursor_image_from_resource(p_cursor, p_hotspot, atlas_rect);
|
|
ERR_FAIL_COND(image.is_null());
|
|
|
|
CustomCursor &cursor = custom_cursors[p_shape];
|
|
|
|
cursor.rid = p_cursor->get_rid();
|
|
cursor.hotspot = p_hotspot;
|
|
|
|
wayland_thread.cursor_shape_set_custom_image(p_shape, image, p_hotspot);
|
|
|
|
if (visible) {
|
|
wayland_thread.cursor_set_custom_shape(p_shape);
|
|
}
|
|
} else {
|
|
// Clear cache and reset to default system cursor.
|
|
if (cursor_shape == p_shape && visible) {
|
|
wayland_thread.cursor_set_shape(p_shape);
|
|
}
|
|
|
|
if (custom_cursors.has(p_shape)) {
|
|
custom_cursors.erase(p_shape);
|
|
}
|
|
|
|
wayland_thread.cursor_shape_clear_custom_image(p_shape);
|
|
}
|
|
}
|
|
|
|
int DisplayServerWayland::keyboard_get_layout_count() const {
|
|
MutexLock mutex_lock(wayland_thread.mutex);
|
|
|
|
return wayland_thread.keyboard_get_layout_count();
|
|
}
|
|
|
|
int DisplayServerWayland::keyboard_get_current_layout() const {
|
|
MutexLock mutex_lock(wayland_thread.mutex);
|
|
|
|
return wayland_thread.keyboard_get_current_layout_index();
|
|
}
|
|
|
|
void DisplayServerWayland::keyboard_set_current_layout(int p_index) {
|
|
MutexLock mutex_lock(wayland_thread.mutex);
|
|
|
|
wayland_thread.keyboard_set_current_layout_index(p_index);
|
|
}
|
|
|
|
String DisplayServerWayland::keyboard_get_layout_language(int p_index) const {
|
|
MutexLock mutex_lock(wayland_thread.mutex);
|
|
|
|
// xkbcommon exposes only the layout's name, which looks like it overlaps with
|
|
// its language.
|
|
return wayland_thread.keyboard_get_layout_name(p_index);
|
|
}
|
|
|
|
String DisplayServerWayland::keyboard_get_layout_name(int p_index) const {
|
|
MutexLock mutex_lock(wayland_thread.mutex);
|
|
|
|
return wayland_thread.keyboard_get_layout_name(p_index);
|
|
}
|
|
|
|
Key DisplayServerWayland::keyboard_get_keycode_from_physical(Key p_keycode) const {
|
|
MutexLock mutex_lock(wayland_thread.mutex);
|
|
|
|
Key key = wayland_thread.keyboard_get_key_from_physical(p_keycode);
|
|
|
|
// If not found, fallback to QWERTY.
|
|
// This should match the behavior of the event pump.
|
|
if (key == Key::NONE) {
|
|
return p_keycode;
|
|
}
|
|
|
|
if (key >= Key::A + 32 && key <= Key::Z + 32) {
|
|
key -= 'a' - 'A';
|
|
}
|
|
|
|
// Make it consistent with the keys returned by `Input`.
|
|
if (key == Key::BACKTAB) {
|
|
key = Key::TAB;
|
|
}
|
|
|
|
return key;
|
|
}
|
|
|
|
void DisplayServerWayland::process_events() {
|
|
wayland_thread.mutex.lock();
|
|
|
|
while (wayland_thread.has_message()) {
|
|
Ref<WaylandThread::Message> msg = wayland_thread.pop_message();
|
|
|
|
Ref<WaylandThread::WindowRectMessage> winrect_msg = msg;
|
|
if (winrect_msg.is_valid()) {
|
|
_resize_window(winrect_msg->rect.size);
|
|
}
|
|
|
|
Ref<WaylandThread::WindowEventMessage> winev_msg = msg;
|
|
if (winev_msg.is_valid()) {
|
|
_send_window_event(winev_msg->event);
|
|
|
|
if (winev_msg->event == WINDOW_EVENT_FOCUS_IN) {
|
|
if (OS::get_singleton()->get_main_loop()) {
|
|
OS::get_singleton()->get_main_loop()->notification(MainLoop::NOTIFICATION_APPLICATION_FOCUS_IN);
|
|
}
|
|
} else if (winev_msg->event == WINDOW_EVENT_FOCUS_OUT) {
|
|
if (OS::get_singleton()->get_main_loop()) {
|
|
OS::get_singleton()->get_main_loop()->notification(MainLoop::NOTIFICATION_APPLICATION_FOCUS_OUT);
|
|
}
|
|
}
|
|
}
|
|
|
|
Ref<WaylandThread::InputEventMessage> inputev_msg = msg;
|
|
if (inputev_msg.is_valid()) {
|
|
Input::get_singleton()->parse_input_event(inputev_msg->event);
|
|
}
|
|
|
|
Ref<WaylandThread::DropFilesEventMessage> dropfiles_msg = msg;
|
|
if (dropfiles_msg.is_valid()) {
|
|
WindowData wd = main_window;
|
|
|
|
if (wd.drop_files_callback.is_valid()) {
|
|
wd.drop_files_callback.call(dropfiles_msg->files);
|
|
}
|
|
}
|
|
}
|
|
|
|
wayland_thread.keyboard_echo_keys();
|
|
|
|
if (!suspended) {
|
|
if (emulate_vsync) {
|
|
// Due to various reasons, we manually handle display synchronization by
|
|
// waiting for a frame event (request to draw) or, if available, the actual
|
|
// window's suspend status. When a window is suspended, we can avoid drawing
|
|
// altogether, either because the compositor told us that we don't need to or
|
|
// because the pace of the frame events became unreliable.
|
|
bool frame = wayland_thread.wait_frame_suspend_ms(1000);
|
|
if (!frame) {
|
|
suspended = true;
|
|
}
|
|
} else {
|
|
if (wayland_thread.is_suspended()) {
|
|
suspended = true;
|
|
}
|
|
}
|
|
|
|
if (suspended) {
|
|
DEBUG_LOG_WAYLAND("Window suspended.");
|
|
}
|
|
} else {
|
|
if (wayland_thread.get_reset_frame()) {
|
|
// At last, a sign of life! We're no longer suspended.
|
|
suspended = false;
|
|
}
|
|
}
|
|
|
|
wayland_thread.mutex.unlock();
|
|
|
|
Input::get_singleton()->flush_buffered_events();
|
|
}
|
|
|
|
void DisplayServerWayland::release_rendering_thread() {
|
|
#ifdef GLES3_ENABLED
|
|
if (egl_manager) {
|
|
egl_manager->release_current();
|
|
}
|
|
#endif
|
|
}
|
|
|
|
void DisplayServerWayland::make_rendering_thread() {
|
|
#ifdef GLES3_ENABLED
|
|
if (egl_manager) {
|
|
egl_manager->make_current();
|
|
}
|
|
#endif
|
|
}
|
|
|
|
void DisplayServerWayland::swap_buffers() {
|
|
#ifdef GLES3_ENABLED
|
|
if (egl_manager) {
|
|
egl_manager->swap_buffers();
|
|
}
|
|
#endif
|
|
}
|
|
|
|
void DisplayServerWayland::set_context(Context p_context) {
|
|
MutexLock mutex_lock(wayland_thread.mutex);
|
|
|
|
DEBUG_LOG_WAYLAND(vformat("Setting context %d.", p_context));
|
|
|
|
context = p_context;
|
|
|
|
String app_id = _get_app_id_from_context(p_context);
|
|
wayland_thread.window_set_app_id(MAIN_WINDOW_ID, app_id);
|
|
}
|
|
|
|
Vector<String> DisplayServerWayland::get_rendering_drivers_func() {
|
|
Vector<String> drivers;
|
|
|
|
#ifdef VULKAN_ENABLED
|
|
drivers.push_back("vulkan");
|
|
#endif
|
|
|
|
#ifdef GLES3_ENABLED
|
|
drivers.push_back("opengl3");
|
|
#endif
|
|
|
|
return drivers;
|
|
}
|
|
|
|
DisplayServer *DisplayServerWayland::create_func(const String &p_rendering_driver, WindowMode p_mode, VSyncMode p_vsync_mode, uint32_t p_flags, const Point2i *p_position, const Size2i &p_resolution, int p_screen, Error &r_error) {
|
|
DisplayServer *ds = memnew(DisplayServerWayland(p_rendering_driver, p_mode, p_vsync_mode, p_flags, p_resolution, r_error));
|
|
if (r_error != OK) {
|
|
ERR_PRINT("Can't create the Wayland display server.");
|
|
memdelete(ds);
|
|
|
|
return nullptr;
|
|
}
|
|
return ds;
|
|
}
|
|
|
|
DisplayServerWayland::DisplayServerWayland(const String &p_rendering_driver, WindowMode p_mode, VSyncMode p_vsync_mode, uint32_t p_flags, const Vector2i &p_resolution, Error &r_error) {
|
|
#ifdef GLES3_ENABLED
|
|
#ifdef SOWRAP_ENABLED
|
|
#ifdef DEBUG_ENABLED
|
|
int dylibloader_verbose = 1;
|
|
#else
|
|
int dylibloader_verbose = 0;
|
|
#endif // DEBUG_ENABLED
|
|
#endif // SOWRAP_ENABLED
|
|
#endif // GLES3_ENABLED
|
|
|
|
r_error = ERR_UNAVAILABLE;
|
|
|
|
Error thread_err = wayland_thread.init();
|
|
|
|
if (thread_err != OK) {
|
|
r_error = thread_err;
|
|
ERR_FAIL_MSG("Could not initialize the Wayland thread.");
|
|
}
|
|
|
|
// Input.
|
|
Input::get_singleton()->set_event_dispatch_function(dispatch_input_events);
|
|
|
|
#ifdef SPEECHD_ENABLED
|
|
// Init TTS
|
|
tts = memnew(TTS_Linux);
|
|
#endif
|
|
|
|
rendering_driver = p_rendering_driver;
|
|
|
|
#ifdef RD_ENABLED
|
|
#ifdef VULKAN_ENABLED
|
|
if (p_rendering_driver == "vulkan") {
|
|
rendering_context = memnew(RenderingContextDriverVulkanWayland);
|
|
}
|
|
#endif
|
|
|
|
if (rendering_context) {
|
|
if (rendering_context->initialize() != OK) {
|
|
ERR_PRINT(vformat("Could not initialize %s", p_rendering_driver));
|
|
memdelete(rendering_context);
|
|
rendering_context = nullptr;
|
|
r_error = ERR_CANT_CREATE;
|
|
return;
|
|
}
|
|
}
|
|
#endif
|
|
|
|
#ifdef GLES3_ENABLED
|
|
if (p_rendering_driver == "opengl3") {
|
|
if (getenv("DRI_PRIME") == nullptr) {
|
|
int prime_idx = -1;
|
|
|
|
if (getenv("PRIMUS_DISPLAY") ||
|
|
getenv("PRIMUS_libGLd") ||
|
|
getenv("PRIMUS_libGLa") ||
|
|
getenv("PRIMUS_libGL") ||
|
|
getenv("PRIMUS_LOAD_GLOBAL") ||
|
|
getenv("BUMBLEBEE_SOCKET") ||
|
|
getenv("__NV_PRIME_RENDER_OFFLOAD")) {
|
|
print_verbose("Optirun/primusrun detected. Skipping GPU detection");
|
|
prime_idx = 0;
|
|
}
|
|
|
|
// Some tools use fake libGL libraries and have them override the real one using
|
|
// LD_LIBRARY_PATH, so we skip them. *But* Steam also sets LD_LIBRARY_PATH for its
|
|
// runtime and includes system `/lib` and `/lib64`... so ignore Steam.
|
|
if (prime_idx == -1 && getenv("LD_LIBRARY_PATH") && !getenv("STEAM_RUNTIME_LIBRARY_PATH")) {
|
|
String ld_library_path(getenv("LD_LIBRARY_PATH"));
|
|
Vector<String> libraries = ld_library_path.split(":");
|
|
|
|
for (int i = 0; i < libraries.size(); ++i) {
|
|
if (FileAccess::exists(libraries[i] + "/libGL.so.1") ||
|
|
FileAccess::exists(libraries[i] + "/libGL.so")) {
|
|
print_verbose("Custom libGL override detected. Skipping GPU detection");
|
|
prime_idx = 0;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (prime_idx == -1) {
|
|
print_verbose("Detecting GPUs, set DRI_PRIME in the environment to override GPU detection logic.");
|
|
prime_idx = DetectPrimeEGL::detect_prime();
|
|
}
|
|
|
|
if (prime_idx) {
|
|
print_line(vformat("Found discrete GPU, setting DRI_PRIME=%d to use it.", prime_idx));
|
|
print_line("Note: Set DRI_PRIME=0 in the environment to disable Godot from using the discrete GPU.");
|
|
setenv("DRI_PRIME", itos(prime_idx).utf8().ptr(), 1);
|
|
}
|
|
}
|
|
|
|
egl_manager = memnew(EGLManagerWayland);
|
|
|
|
#ifdef SOWRAP_ENABLED
|
|
if (initialize_wayland_egl(dylibloader_verbose) != 0) {
|
|
WARN_PRINT("Can't load the Wayland EGL library.");
|
|
return;
|
|
}
|
|
#endif // SOWRAP_ENABLED
|
|
|
|
if (egl_manager->initialize() != OK) {
|
|
memdelete(egl_manager);
|
|
egl_manager = nullptr;
|
|
r_error = ERR_CANT_CREATE;
|
|
ERR_FAIL_MSG("Could not initialize GLES3.");
|
|
}
|
|
|
|
RasterizerGLES3::make_current(true);
|
|
}
|
|
#endif // GLES3_ENABLED
|
|
|
|
cursor_set_shape(CURSOR_BUSY);
|
|
|
|
WindowData &wd = main_window;
|
|
|
|
wd.id = MAIN_WINDOW_ID;
|
|
wd.mode = p_mode;
|
|
wd.flags = p_flags;
|
|
wd.vsync_mode = p_vsync_mode;
|
|
wd.rect.size = p_resolution;
|
|
wd.title = "Godot";
|
|
|
|
_show_window();
|
|
|
|
#ifdef RD_ENABLED
|
|
if (rendering_context) {
|
|
rendering_device = memnew(RenderingDevice);
|
|
rendering_device->initialize(rendering_context, MAIN_WINDOW_ID);
|
|
rendering_device->screen_create(MAIN_WINDOW_ID);
|
|
|
|
RendererCompositorRD::make_current();
|
|
}
|
|
#endif
|
|
|
|
#ifdef DBUS_ENABLED
|
|
portal_desktop = memnew(FreeDesktopPortalDesktop);
|
|
screensaver = memnew(FreeDesktopScreenSaver);
|
|
#endif
|
|
|
|
screen_set_keep_on(GLOBAL_GET("display/window/energy_saving/keep_screen_on"));
|
|
|
|
r_error = OK;
|
|
}
|
|
|
|
DisplayServerWayland::~DisplayServerWayland() {
|
|
// TODO: Multiwindow support.
|
|
if (main_window.visible) {
|
|
#ifdef VULKAN_ENABLED
|
|
if (rendering_device) {
|
|
rendering_device->screen_free(MAIN_WINDOW_ID);
|
|
}
|
|
|
|
if (rendering_context) {
|
|
rendering_context->window_destroy(MAIN_WINDOW_ID);
|
|
}
|
|
#endif
|
|
|
|
#ifdef GLES3_ENABLED
|
|
if (egl_manager) {
|
|
egl_manager->window_destroy(MAIN_WINDOW_ID);
|
|
}
|
|
#endif
|
|
}
|
|
|
|
#ifdef GLES3_ENABLED
|
|
if (main_window.wl_egl_window) {
|
|
wl_egl_window_destroy(main_window.wl_egl_window);
|
|
}
|
|
#endif
|
|
|
|
wayland_thread.destroy();
|
|
|
|
// Destroy all drivers.
|
|
#ifdef RD_ENABLED
|
|
if (rendering_device) {
|
|
memdelete(rendering_device);
|
|
}
|
|
|
|
if (rendering_context) {
|
|
memdelete(rendering_context);
|
|
}
|
|
#endif
|
|
|
|
#ifdef SPEECHD_ENABLED
|
|
if (tts) {
|
|
memdelete(tts);
|
|
}
|
|
#endif
|
|
|
|
#ifdef DBUS_ENABLED
|
|
if (portal_desktop) {
|
|
memdelete(portal_desktop);
|
|
memdelete(screensaver);
|
|
}
|
|
#endif
|
|
}
|
|
|
|
void DisplayServerWayland::register_wayland_driver() {
|
|
register_create_function("wayland", create_func, get_rendering_drivers_func);
|
|
}
|
|
|
|
#endif //WAYLAND_ENABLED
|