Implement an editor to customize the touchscreen controls (#14933)

- The editor is accessible via the pause menu and the settings menu. - Buttons can be moved via drag & drop. - Buttons can be added/removed. The grid menu added by #14918 is used to show all buttons not included in the layout. - Custom layouts are responsive and adapt to changed screen size / DPI / hud_scaling. - The layout is saved as JSON in the "touch_layout" setting.
2025-11-13 05:15:28 +01:00 · 2024-11-24 11:33:39 +01:00
parent 4faa16fe0d
commit 6a1d22b2c5
18 changed files with 1122 additions and 195 deletions
--- a/src/gui/touchscreeneditor.cpp
+++ b/src/gui/touchscreeneditor.cpp
@@ -0,0 +1,404 @@
+// Luanti
+// SPDX-License-Identifier: LGPL-2.1-or-later
+// Copyright (C) 2024 grorp, Gregor Parzefall <grorp@posteo.de>
+
+#include "touchscreeneditor.h"
+#include "touchcontrols.h"
+#include "touchscreenlayout.h"
+
+#include "client/renderingengine.h"
+#include "gettext.h"
+#include "irr_gui_ptr.h"
+#include "settings.h"
+
+#include "IGUIButton.h"
+#include "IGUIFont.h"
+#include "IGUIImage.h"
+#include "IGUIStaticText.h"
+
+GUITouchscreenLayout::GUITouchscreenLayout(gui::IGUIEnvironment* env,
+		gui::IGUIElement* parent, s32 id,
+		IMenuManager *menumgr, ISimpleTextureSource *tsrc
+):
+	GUIModalMenu(env, parent, id, menumgr),
+	m_tsrc(tsrc)
+{
+	if (g_touchcontrols)
+		m_layout = g_touchcontrols->getLayout();
+	else
+		m_layout = ButtonLayout::loadFromSettings();
+
+	m_gui_help_text = grab_gui_element<IGUIStaticText>(Environment->addStaticText(
+			L"", core::recti(), false, false, this, -1));
+	m_gui_help_text->setTextAlignment(EGUIA_CENTER, EGUIA_CENTER);
+
+	m_gui_add_btn = grab_gui_element<IGUIButton>(Environment->addButton(
+			core::recti(), this, -1, wstrgettext("Add button").c_str()));
+	m_gui_reset_btn = grab_gui_element<IGUIButton>(Environment->addButton(
+			core::recti(), this, -1, wstrgettext("Reset").c_str()));
+	m_gui_done_btn = grab_gui_element<IGUIButton>(Environment->addButton(
+			core::recti(), this, -1, wstrgettext("Done").c_str()));
+
+	m_gui_remove_btn = grab_gui_element<IGUIButton>(Environment->addButton(
+		core::recti(), this, -1, wstrgettext("Remove").c_str()));
+}
+
+GUITouchscreenLayout::~GUITouchscreenLayout()
+{
+	ButtonLayout::clearTextureCache();
+}
+
+void GUITouchscreenLayout::regenerateGui(v2u32 screensize)
+{
+	DesiredRect = core::recti(0, 0, screensize.X, screensize.Y);
+	recalculateAbsolutePosition(false);
+
+	s32 button_size = ButtonLayout::getButtonSize(screensize);
+	if (m_last_screensize != screensize || m_button_size != button_size) {
+		m_last_screensize = screensize;
+		m_button_size = button_size;
+		// Prevent interpolation when the layout scales.
+		clearGUIImages();
+	}
+
+	// Discard invalid selection. May happen when...
+	// 1. a button is removed.
+	// 2. adding a button fails and it disappears from the layout again.
+	if (m_selected_btn != touch_gui_button_id_END &&
+			m_layout.layout.count(m_selected_btn) == 0)
+		m_selected_btn = touch_gui_button_id_END;
+
+	if (m_mode == Mode::Add)
+		regenerateGUIImagesAddMode(screensize);
+	else
+		regenerateGUIImagesRegular(screensize);
+	regenerateMenu(screensize);
+}
+
+void GUITouchscreenLayout::clearGUIImages()
+{
+	m_gui_images.clear();
+	m_gui_images_target_pos.clear();
+
+	m_add_layout.layout.clear();
+	m_add_button_titles.clear();
+}
+
+void GUITouchscreenLayout::regenerateGUIImagesRegular(v2u32 screensize)
+{
+	assert(m_mode != Mode::Add);
+
+	auto old_gui_images = m_gui_images;
+	clearGUIImages();
+
+	for (const auto &[btn, meta] : m_layout.layout) {
+		core::recti rect = m_layout.getRect(btn, screensize, m_button_size, m_tsrc);
+		std::shared_ptr<IGUIImage> img;
+
+		if (old_gui_images.count(btn) > 0) {
+			img = old_gui_images.at(btn);
+			// Update size, keep position. Position is interpolated in interpolateGUIImages.
+			img->setRelativePosition(core::recti(
+					img->getRelativePosition().UpperLeftCorner, rect.getSize()));
+		} else {
+			img = grab_gui_element<IGUIImage>(Environment->addImage(rect, this, -1));
+			img->setImage(ButtonLayout::getTexture(btn, m_tsrc));
+			img->setScaleImage(true);
+		}
+
+		m_gui_images[btn] = img;
+		m_gui_images_target_pos[btn] = rect.UpperLeftCorner;
+	}
+}
+
+void GUITouchscreenLayout::regenerateGUIImagesAddMode(v2u32 screensize)
+{
+	assert(m_mode == Mode::Add);
+
+	clearGUIImages();
+
+	auto missing_buttons = m_layout.getMissingButtons();
+
+	layout_button_grid(screensize, m_tsrc, missing_buttons,
+			[&] (touch_gui_button_id btn, v2s32 pos, core::recti rect) {
+		auto img = grab_gui_element<IGUIImage>(Environment->addImage(rect, this, -1));
+		img->setImage(ButtonLayout::getTexture(btn, m_tsrc));
+		img->setScaleImage(true);
+		m_gui_images[btn] = img;
+
+		ButtonMeta meta;
+		meta.setPos(pos, screensize, m_button_size);
+		m_add_layout.layout[btn] = meta;
+
+		IGUIStaticText *text = Environment->addStaticText(L"", core::recti(),
+				false, false,this, -1);
+		make_button_grid_title(text, btn, pos, rect);
+		m_add_button_titles.push_back(grab_gui_element<IGUIStaticText>(text));
+	});
+}
+
+void GUITouchscreenLayout::interpolateGUIImages()
+{
+	if (m_mode == Mode::Add)
+		return;
+
+	for (auto &[btn, gui_image] : m_gui_images) {
+		bool interpolate = m_mode != Mode::Dragging || m_selected_btn != btn;
+
+		v2s32 cur_pos_int = gui_image->getRelativePosition().UpperLeftCorner;
+		v2s32 tgt_pos_int = m_gui_images_target_pos.at(btn);
+		v2f cur_pos(cur_pos_int.X, cur_pos_int.Y);
+		v2f tgt_pos(tgt_pos_int.X, tgt_pos_int.Y);
+
+		if (interpolate && cur_pos.getDistanceFrom(tgt_pos) > 2.0f) {
+			v2f pos = cur_pos.getInterpolated(tgt_pos, 0.5f);
+			gui_image->setRelativePosition(v2s32(core::round32(pos.X), core::round32(pos.Y)));
+		} else {
+			gui_image->setRelativePosition(tgt_pos_int);
+		}
+	}
+}
+
+static void layout_menu_row(v2u32 screensize,
+		const std::vector<std::shared_ptr<IGUIButton>> &row,
+		const std::vector<std::shared_ptr<IGUIButton>> &full_row, bool bottom)
+{
+	s32 spacing = RenderingEngine::getDisplayDensity() * 4.0f;
+
+	s32 btn_w = 0;
+	s32 btn_h = 0;
+	for (const auto &btn : full_row) {
+		IGUIFont *font = btn->getActiveFont();
+		core::dimension2du dim = font->getDimension(btn->getText());
+		btn_w = std::max(btn_w, (s32)(dim.Width * 1.5f));
+		btn_h = std::max(btn_h, (s32)(dim.Height * 2.5f));
+	}
+
+	const s32 row_width = ((btn_w + spacing) * row.size()) - spacing;
+	s32 x = screensize.X / 2 - row_width / 2;
+	const s32 y = bottom ? screensize.Y - spacing - btn_h : spacing;
+
+	for (const auto &btn : row) {
+		btn->setRelativePosition(core::recti(
+				v2s32(x, y), core::dimension2du(btn_w, btn_h)));
+		x += btn_w + spacing;
+	}
+}
+
+void GUITouchscreenLayout::regenerateMenu(v2u32 screensize)
+{
+	bool have_selection = m_selected_btn != touch_gui_button_id_END;
+
+	if (m_mode == Mode::Add)
+		m_gui_help_text->setText(wstrgettext("Start dragging a button to add. Tap outside to cancel.").c_str());
+	else if (!have_selection)
+		m_gui_help_text->setText(wstrgettext("Tap a button to select it. Drag a button to move it.").c_str());
+	else
+		m_gui_help_text->setText(wstrgettext("Tap outside to deselect.").c_str());
+
+	IGUIFont *font = m_gui_help_text->getActiveFont();
+	core::dimension2du dim = font->getDimension(m_gui_help_text->getText());
+	s32 height = dim.Height * 2.5f;
+	s32 pos_y = (m_mode == Mode::Add || have_selection) ? 0 : screensize.Y - height;
+	m_gui_help_text->setRelativePosition(core::recti(
+			v2s32(0, pos_y),
+			core::dimension2du(screensize.X, height)));
+
+	bool normal_buttons_visible = m_mode != Mode::Add && !have_selection;
+	bool add_visible = normal_buttons_visible && !m_layout.getMissingButtons().empty();
+
+	m_gui_add_btn->setVisible(add_visible);
+	m_gui_reset_btn->setVisible(normal_buttons_visible);
+	m_gui_done_btn->setVisible(normal_buttons_visible);
+
+	if (normal_buttons_visible) {
+		std::vector row1{m_gui_add_btn, m_gui_reset_btn, m_gui_done_btn};
+		if (add_visible) {
+			layout_menu_row(screensize, row1, row1, false);
+		} else {
+			std::vector row1_reduced{m_gui_reset_btn, m_gui_done_btn};
+			layout_menu_row(screensize, row1_reduced, row1, false);
+		}
+	}
+
+	bool remove_visible = m_mode != Mode::Add && have_selection &&
+			!ButtonLayout::isButtonRequired(m_selected_btn);
+
+	m_gui_remove_btn->setVisible(remove_visible);
+
+	if (remove_visible) {
+		std::vector row2{m_gui_remove_btn};
+		layout_menu_row(screensize, row2, row2, true);
+	}
+}
+
+void GUITouchscreenLayout::drawMenu()
+{
+	video::IVideoDriver *driver = Environment->getVideoDriver();
+
+	video::SColor bgcolor(140, 0, 0, 0);
+	video::SColor selection_color(255, 128, 128, 128);
+	video::SColor error_color(255, 255, 0, 0);
+
+	driver->draw2DRectangle(bgcolor, AbsoluteRect, &AbsoluteClippingRect);
+
+	// Done here instead of in OnPostRender to avoid drag&drop lagging behind
+	// input by one frame.
+	// Must be done before drawing selection rectangle.
+	interpolateGUIImages();
+
+	bool draw_selection = m_gui_images.count(m_selected_btn) > 0;
+	if (draw_selection)
+		driver->draw2DRectangle(selection_color,
+				m_gui_images.at(m_selected_btn)->getAbsolutePosition(),
+				&AbsoluteClippingRect);
+
+	if (m_mode == Mode::Dragging) {
+		for (const auto &rect : m_error_rects)
+			driver->draw2DRectangle(error_color, rect, &AbsoluteClippingRect);
+	}
+
+	IGUIElement::draw();
+}
+
+void GUITouchscreenLayout::updateDragState(v2u32 screensize, v2s32 mouse_movement)
+{
+	assert(m_mode == Mode::Dragging);
+
+	core::recti rect = m_layout.getRect(m_selected_btn, screensize, m_button_size, m_tsrc);
+	rect += mouse_movement;
+	rect.constrainTo(core::recti(v2s32(0, 0), core::dimension2du(screensize)));
+
+	ButtonMeta &meta = m_layout.layout.at(m_selected_btn);
+	meta.setPos(rect.getCenter(), screensize, m_button_size);
+
+	rect = m_layout.getRect(m_selected_btn, screensize, m_button_size, m_tsrc);
+
+	m_error_rects.clear();
+	for (const auto &[other_btn, other_meta] : m_layout.layout) {
+		if (other_btn == m_selected_btn)
+			continue;
+		core::recti other_rect = m_layout.getRect(other_btn, screensize, m_button_size, m_tsrc);
+		if (other_rect.isRectCollided(rect))
+			m_error_rects.push_back(other_rect);
+	}
+	if (m_error_rects.empty())
+		m_last_good_layout = m_layout;
+}
+
+bool GUITouchscreenLayout::OnEvent(const SEvent& event)
+{
+	if (event.EventType == EET_KEY_INPUT_EVENT) {
+		if (event.KeyInput.Key == KEY_ESCAPE && event.KeyInput.PressedDown) {
+			quitMenu();
+			return true;
+		}
+	}
+
+	core::dimension2du screensize = Environment->getVideoDriver()->getScreenSize();
+
+	if (event.EventType == EET_MOUSE_INPUT_EVENT) {
+		v2s32 mouse_pos = v2s32(event.MouseInput.X, event.MouseInput.Y);
+
+		switch (event.MouseInput.Event) {
+		case EMIE_LMOUSE_PRESSED_DOWN: {
+			m_mouse_down = true;
+			m_last_mouse_pos = mouse_pos;
+
+			IGUIElement *el = Environment->getRootGUIElement()->getElementFromPoint(mouse_pos);
+			// Clicking on nothing deselects.
+			m_selected_btn = touch_gui_button_id_END;
+			for (const auto &[btn, gui_image] : m_gui_images) {
+				if (el == gui_image.get()) {
+					m_selected_btn = btn;
+					break;
+				}
+			}
+
+			if (m_mode == Mode::Add) {
+				if (m_selected_btn != touch_gui_button_id_END) {
+					m_mode = Mode::Dragging;
+					m_last_good_layout = m_layout;
+					m_layout.layout[m_selected_btn] = m_add_layout.layout.at(m_selected_btn);
+					updateDragState(screensize, v2s32(0, 0));
+				} else {
+					// Clicking on nothing quits add mode without adding a button.
+					m_mode = Mode::Default;
+				}
+			}
+
+			regenerateGui(screensize);
+			return true;
+		}
+		case EMIE_MOUSE_MOVED: {
+			if (m_mouse_down && m_selected_btn != touch_gui_button_id_END) {
+				if (m_mode != Mode::Dragging) {
+					m_mode = Mode::Dragging;
+					m_last_good_layout = m_layout;
+				}
+				updateDragState(screensize, mouse_pos - m_last_mouse_pos);
+
+				regenerateGui(screensize);
+			}
+
+			m_last_mouse_pos = mouse_pos;
+			return true;
+		}
+		case EMIE_LMOUSE_LEFT_UP: {
+			m_mouse_down = false;
+
+			if (m_mode == Mode::Dragging) {
+				m_mode = Mode::Default;
+				if (!m_error_rects.empty())
+					m_layout = m_last_good_layout;
+
+				regenerateGui(screensize);
+			}
+
+			return true;
+		}
+		default:
+			break;
+		}
+	}
+
+	if (event.EventType == EET_GUI_EVENT) {
+		switch (event.GUIEvent.EventType) {
+		case EGET_BUTTON_CLICKED: {
+			if (event.GUIEvent.Caller == m_gui_add_btn.get()) {
+				m_mode = Mode::Add;
+				regenerateGui(screensize);
+				return true;
+			}
+
+			if (event.GUIEvent.Caller == m_gui_reset_btn.get()) {
+				m_layout = ButtonLayout::predefined;
+				regenerateGui(screensize);
+				return true;
+			}
+
+			if (event.GUIEvent.Caller == m_gui_done_btn.get()) {
+				if (g_touchcontrols)
+					g_touchcontrols->applyLayout(m_layout);
+				std::ostringstream oss;
+				m_layout.serializeJson(oss);
+				g_settings->set("touch_layout", oss.str());
+				quitMenu();
+				return true;
+			}
+
+			if (event.GUIEvent.Caller == m_gui_remove_btn.get()) {
+				m_layout.layout.erase(m_selected_btn);
+				regenerateGui(screensize);
+				return true;
+			}
+
+			break;
+		}
+		default:
+			break;
+		}
+	}
+
+	return Parent ? Parent->OnEvent(event) : false;
+}