Add support for touchpad and sensor handling via SDL

This should enable support for more controllers besides the DS4 and DualSense, basically any controller supported by SDL that has at least one touchpad, an accelerometer and a gyroscope. Older SDL versions have been tested down to 2.0.9. Versions older than 2.0.14 won't have sensors and touchpad support, though. Setsu is deprecated and remains in-tree for now, but defaults to being disabled if SDL2 is found and >= 2.0.14. If Setsu is enabled explicitly, touchpad and sensors are not handled by SDL.
2025-07-05 20:42:08 -07:00 · 2022-11-07 22:50:32 +01:00 · 2022-11-07 22:50:32 +01:00 · 4c8209762c
commit 4c8209762c
parent 76690a319c
9 changed files with 298 additions and 59 deletions
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@ -150,21 +150,30 @@ if(CHIAKI_ENABLE_CLI)
 	add_subdirectory(cli)
 endif()

+if(CHIAKI_ENABLE_GUI AND CHIAKI_GUI_ENABLE_SDL_GAMECONTROLLER)
+	find_package(SDL2 MODULE REQUIRED)
+endif()
+
 if(CHIAKI_ENABLE_SETSU)
-	find_package(Udev QUIET)
-	find_package(Evdev QUIET)
-	if(Udev_FOUND AND Evdev_FOUND)
-		set(CHIAKI_ENABLE_SETSU ON)
-	else()
-		if(NOT CHIAKI_ENABLE_SETSU STREQUAL AUTO)
-			message(FATAL_ERROR "
-CHIAKI_ENABLE_SETSU is set to ON, but its dependencies (udev and evdev) could not be resolved.
-Keep in mind that setsu is only supported on Linux!")
-		endif()
+	if(CHIAKI_ENABLE_SETSU STREQUAL AUTO AND SDL2_FOUND AND (SDL2_VERSION_MINOR GREATER 0 OR SDL2_VERSION_PATCH GREATER_EQUAL 14))
+		message(STATUS "SDL version ${SDL2_VERSION} is >= 2.0.14, disabling Setsu")
 		set(CHIAKI_ENABLE_SETSU OFF)
-	endif()
-	if(CHIAKI_ENABLE_SETSU)
-		add_subdirectory(setsu)
+	else()
+		find_package(Udev QUIET)
+		find_package(Evdev QUIET)
+		if(Udev_FOUND AND Evdev_FOUND)
+			set(CHIAKI_ENABLE_SETSU ON)
+		else()
+			if(NOT CHIAKI_ENABLE_SETSU STREQUAL AUTO)
+				message(FATAL_ERROR "
+	CHIAKI_ENABLE_SETSU is set to ON, but its dependencies (udev and evdev) could not be resolved.
+	Keep in mind that setsu is only supported on Linux!")
+			endif()
+			set(CHIAKI_ENABLE_SETSU OFF)
+		endif()
+		if(CHIAKI_ENABLE_SETSU)
+			add_subdirectory(setsu)
+		endif()
 	endif()
 endif()

@ -175,7 +184,6 @@ else()
 endif()

 if(CHIAKI_ENABLE_GUI)
-	#add_subdirectory(setsu)
 	add_subdirectory(gui)
 endif()

--- a/cmake/FindSDL2.cmake
+++ b/cmake/FindSDL2.cmake
@ -1,6 +1,26 @@

 find_package(SDL2 NO_MODULE QUIET)

+# Adapted from libsdl-org/SDL_ttf: https://github.com/libsdl-org/SDL_ttf/blob/main/cmake/FindPrivateSDL2.cmake#L19-L31
+# Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
+# Licensed under the zlib license (https://github.com/libsdl-org/SDL_ttf/blob/main/LICENSE.txt)
+set(SDL2_VERSION_MAJOR)
+set(SDL2_VERSION_MINOR)
+set(SDL2_VERSION_PATCH)
+set(SDL2_VERSION)
+if(SDL2_INCLUDE_DIR)
+    file(READ "${SDL2_INCLUDE_DIR}/SDL_version.h" _sdl_version_h)
+    string(REGEX MATCH "#define[ \t]+SDL_MAJOR_VERSION[ \t]+([0-9]+)" _sdl2_major_re "${_sdl_version_h}")
+    set(SDL2_VERSION_MAJOR "${CMAKE_MATCH_1}")
+    string(REGEX MATCH "#define[ \t]+SDL_MINOR_VERSION[ \t]+([0-9]+)" _sdl2_minor_re "${_sdl_version_h}")
+    set(SDL2_VERSION_MINOR "${CMAKE_MATCH_1}")
+    string(REGEX MATCH "#define[ \t]+SDL_PATCHLEVEL[ \t]+([0-9]+)" _sdl2_patch_re "${_sdl_version_h}")
+    set(SDL2_VERSION_PATCH "${CMAKE_MATCH_1}")
+	if(_sdl2_major_re AND _sdl2_minor_re AND _sdl2_patch_re)
+		set(SDL2_VERSION "${SDL2_VERSION_MAJOR}.${SDL2_VERSION_MINOR}.${SDL2_VERSION_PATCH}")
+    endif()
+endif()
+
 if(SDL2_FOUND AND (NOT TARGET SDL2::SDL2))
 	add_library(SDL2::SDL2 UNKNOWN IMPORTED GLOBAL)
 	if(NOT SDL2_LIBDIR)
--- a/gui/CMakeLists.txt
+++ b/gui/CMakeLists.txt
@ -6,9 +6,6 @@ find_package(Qt5 REQUIRED COMPONENTS Core Widgets Gui Concurrent Multimedia Open
 if(APPLE)
 	find_package(Qt5 REQUIRED COMPONENTS MacExtras)
 endif()
-if(CHIAKI_GUI_ENABLE_SDL_GAMECONTROLLER)
-	find_package(SDL2 MODULE REQUIRED)
-endif()

 if(WIN32)
 	add_definitions(-DWIN32_LEAN_AND_MEAN)
--- a/gui/include/controllermanager.h
+++ b/gui/include/controllermanager.h
@ -12,8 +12,12 @@

 #ifdef CHIAKI_GUI_ENABLE_SDL_GAMECONTROLLER
 #include <SDL.h>
+#include <chiaki/orientation.h>
 #endif

+#define PS_TOUCHPAD_MAX_X 1920
+#define PS_TOUCHPAD_MAX_Y 1079
+
 class Controller;

 class ControllerManager : public QObject
@ -33,7 +37,9 @@ class ControllerManager : public QObject
 	private slots:
 		void UpdateAvailableControllers();
 		void HandleEvents();
-		void ControllerEvent(int device_id);
+#ifdef CHIAKI_GUI_ENABLE_SDL_GAMECONTROLLER
+		void ControllerEvent(SDL_Event evt);
+#endif

 	public:
 		static ControllerManager *GetInstance();
@ -57,12 +63,23 @@ class Controller : public QObject
 	private:
 		Controller(int device_id, ControllerManager *manager);

-		void UpdateState();
+#ifdef CHIAKI_GUI_ENABLE_SDL_GAMECONTROLLER
+		void UpdateState(SDL_Event event);
+		bool HandleButtonEvent(SDL_ControllerButtonEvent event);
+		bool HandleAxisEvent(SDL_ControllerAxisEvent event);
+#if SDL_VERSION_ATLEAST(2, 0, 14)
+		bool HandleSensorEvent(SDL_ControllerSensorEvent event);
+		bool HandleTouchpadEvent(SDL_ControllerTouchpadEvent event);
+#endif
+#endif

 		ControllerManager *manager;
 		int id;
+		ChiakiOrientationTracker orientation_tracker;
+		ChiakiControllerState state;

 #ifdef CHIAKI_GUI_ENABLE_SDL_GAMECONTROLLER
+		QMap<QPair<Sint64, Sint64>, uint8_t> touch_ids;
 		SDL_GameController *controller;
 #endif

--- a/gui/src/controllermanager.cpp
+++ b/gui/src/controllermanager.cpp
@ -156,22 +156,51 @@ void ControllerManager::HandleEvents()
 				break;
 			case SDL_CONTROLLERBUTTONUP:
 			case SDL_CONTROLLERBUTTONDOWN:
-				ControllerEvent(event.cbutton.which);
-				break;
 			case SDL_CONTROLLERAXISMOTION:
-				ControllerEvent(event.caxis.which);
+#if not defined(CHIAKI_ENABLE_SETSU) and SDL_VERSION_ATLEAST(2, 0, 14)
+			case SDL_CONTROLLERSENSORUPDATE:
+			case SDL_CONTROLLERTOUCHPADDOWN:
+			case SDL_CONTROLLERTOUCHPADMOTION:
+			case SDL_CONTROLLERTOUCHPADUP:
+#endif
+				ControllerEvent(event);
 				break;
 		}
 	}
 #endif
 }

-void ControllerManager::ControllerEvent(int device_id)
+#ifdef CHIAKI_GUI_ENABLE_SDL_GAMECONTROLLER
+void ControllerManager::ControllerEvent(SDL_Event event)
 {
+	int device_id;
+	switch(event.type)
+	{
+		case SDL_CONTROLLERBUTTONDOWN:
+		case SDL_CONTROLLERBUTTONUP:
+			device_id = event.cbutton.which;
+			break;
+		case SDL_CONTROLLERAXISMOTION:
+			device_id = event.caxis.which;
+			break;
+#if SDL_VERSION_ATLEAST(2, 0, 14)
+		case SDL_CONTROLLERSENSORUPDATE:
+			device_id = event.csensor.which;
+			break;
+		case SDL_CONTROLLERTOUCHPADDOWN:
+		case SDL_CONTROLLERTOUCHPADMOTION:
+		case SDL_CONTROLLERTOUCHPADUP:
+			device_id = event.ctouchpad.which;
+			break;
+#endif
+		default:
+			return;
+	}
 	if(!open_controllers.contains(device_id))
 		return;
-	open_controllers[device_id]->UpdateState();
+	open_controllers[device_id]->UpdateState(event);
 }
+#endif

 QSet<int> ControllerManager::GetAvailableControllers()
 {
@ -200,6 +229,8 @@ Controller::Controller(int device_id, ControllerManager *manager) : QObject(mana
 {
 	this->id = device_id;
 	this->manager = manager;
+	chiaki_orientation_tracker_init(&this->orientation_tracker);
+	chiaki_controller_state_set_idle(&this->state);

 #ifdef CHIAKI_GUI_ENABLE_SDL_GAMECONTROLLER
 	controller = nullptr;
@ -208,7 +239,13 @@ Controller::Controller(int device_id, ControllerManager *manager) : QObject(mana
 		if(SDL_JoystickGetDeviceInstanceID(i) == device_id)
 		{
 			controller = SDL_GameControllerOpen(i);
+#if SDL_VERSION_ATLEAST(2, 0, 14)
+			if(SDL_GameControllerHasSensor(controller, SDL_SENSOR_ACCEL))
+				SDL_GameControllerSetSensorEnabled(controller, SDL_SENSOR_ACCEL, SDL_TRUE);
+			if(SDL_GameControllerHasSensor(controller, SDL_SENSOR_GYRO))
+				SDL_GameControllerSetSensorEnabled(controller, SDL_SENSOR_GYRO, SDL_TRUE);
 			break;
+#endif
 		}
 	}
 #endif
@ -223,11 +260,187 @@ Controller::~Controller()
 	manager->ControllerClosed(this);
 }

-void Controller::UpdateState()
+#ifdef CHIAKI_GUI_ENABLE_SDL_GAMECONTROLLER
+void Controller::UpdateState(SDL_Event event)
 {
+	switch(event.type)
+	{
+		case SDL_CONTROLLERBUTTONDOWN:
+		case SDL_CONTROLLERBUTTONUP:
+			if(!HandleButtonEvent(event.cbutton))
+				return;
+			break;
+		case SDL_CONTROLLERAXISMOTION:
+			if(!HandleAxisEvent(event.caxis))
+				return;
+			break;
+#if SDL_VERSION_ATLEAST(2, 0, 14)
+		case SDL_CONTROLLERSENSORUPDATE:
+			if(!HandleSensorEvent(event.csensor))
+				return;
+			break;
+		case SDL_CONTROLLERTOUCHPADDOWN:
+		case SDL_CONTROLLERTOUCHPADMOTION:
+		case SDL_CONTROLLERTOUCHPADUP:
+			if(!HandleTouchpadEvent(event.ctouchpad))
+				return;
+			break;
+#endif
+		default:
+			return;
+
+	}
 	emit StateChanged();
 }

+inline bool Controller::HandleButtonEvent(SDL_ControllerButtonEvent event) {
+	ChiakiControllerButton ps_btn;
+	switch(event.button)
+	{
+		case SDL_CONTROLLER_BUTTON_A:
+			ps_btn = CHIAKI_CONTROLLER_BUTTON_CROSS;
+			break;
+		case SDL_CONTROLLER_BUTTON_B:
+			ps_btn = CHIAKI_CONTROLLER_BUTTON_MOON;
+			break;
+		case SDL_CONTROLLER_BUTTON_X:
+			ps_btn = CHIAKI_CONTROLLER_BUTTON_BOX;
+			break;
+		case SDL_CONTROLLER_BUTTON_Y:
+			ps_btn = CHIAKI_CONTROLLER_BUTTON_PYRAMID;
+			break;
+		case SDL_CONTROLLER_BUTTON_DPAD_LEFT:
+			ps_btn = CHIAKI_CONTROLLER_BUTTON_DPAD_LEFT;
+			break;
+		case SDL_CONTROLLER_BUTTON_DPAD_RIGHT:
+			ps_btn = CHIAKI_CONTROLLER_BUTTON_DPAD_RIGHT;
+			break;
+		case SDL_CONTROLLER_BUTTON_DPAD_UP:
+			ps_btn = CHIAKI_CONTROLLER_BUTTON_DPAD_UP;
+			break;
+		case SDL_CONTROLLER_BUTTON_DPAD_DOWN:
+			ps_btn = CHIAKI_CONTROLLER_BUTTON_DPAD_DOWN;
+			break;
+		case SDL_CONTROLLER_BUTTON_LEFTSHOULDER:
+			ps_btn = CHIAKI_CONTROLLER_BUTTON_L1;
+			break;
+		case SDL_CONTROLLER_BUTTON_RIGHTSHOULDER:
+			ps_btn = CHIAKI_CONTROLLER_BUTTON_R1;
+			break;
+		case SDL_CONTROLLER_BUTTON_LEFTSTICK:
+			ps_btn = CHIAKI_CONTROLLER_BUTTON_L3;
+			break;
+		case SDL_CONTROLLER_BUTTON_RIGHTSTICK:
+			ps_btn = CHIAKI_CONTROLLER_BUTTON_R3;
+			break;
+		case SDL_CONTROLLER_BUTTON_START:
+			ps_btn = CHIAKI_CONTROLLER_BUTTON_OPTIONS;
+			break;
+		case SDL_CONTROLLER_BUTTON_BACK:
+			ps_btn = CHIAKI_CONTROLLER_BUTTON_SHARE;
+			break;
+		case SDL_CONTROLLER_BUTTON_GUIDE:
+			ps_btn = CHIAKI_CONTROLLER_BUTTON_PS;
+			break;
+#if SDL_VERSION_ATLEAST(2, 0, 14)
+		case SDL_CONTROLLER_BUTTON_TOUCHPAD:
+			ps_btn = CHIAKI_CONTROLLER_BUTTON_TOUCHPAD;
+			break;
+#endif
+		default:
+			return false;
+		}
+	if(event.type == SDL_CONTROLLERBUTTONDOWN)
+		state.buttons |= ps_btn;
+	else
+		state.buttons &= ~ps_btn;
+	return true;
+}
+
+inline bool Controller::HandleAxisEvent(SDL_ControllerAxisEvent event) {
+	switch(event.axis)
+	{
+		case SDL_CONTROLLER_AXIS_TRIGGERLEFT:
+			state.l2_state = (uint8_t)(event.value >> 7);
+			break;
+		case SDL_CONTROLLER_AXIS_TRIGGERRIGHT:
+			state.r2_state = (uint8_t)(event.value >> 7);
+			break;
+		case SDL_CONTROLLER_AXIS_LEFTX:
+			state.left_x = event.value;
+			break;
+		case SDL_CONTROLLER_AXIS_LEFTY:
+			state.left_y = event.value;
+			break;
+		case SDL_CONTROLLER_AXIS_RIGHTX:
+			state.right_x = event.value;
+			break;
+		case SDL_CONTROLLER_AXIS_RIGHTY:
+			state.right_y = event.value;
+			break;
+		default:
+			return false;
+	}
+	return true;
+}
+
+#if SDL_VERSION_ATLEAST(2, 0, 14)
+inline bool Controller::HandleSensorEvent(SDL_ControllerSensorEvent event)
+{
+	switch(event.sensor)
+	{
+		case SDL_SENSOR_ACCEL:
+			state.accel_x = event.data[0] / SDL_STANDARD_GRAVITY;
+			state.accel_y = event.data[1] / SDL_STANDARD_GRAVITY;
+			state.accel_z = event.data[2] / SDL_STANDARD_GRAVITY;
+			break;
+		case SDL_SENSOR_GYRO:
+			state.gyro_x = event.data[0];
+			state.gyro_y = event.data[1];
+			state.gyro_z = event.data[2];
+			break;
+		default:
+			return false;
+	}
+	chiaki_orientation_tracker_update(
+		&orientation_tracker, state.gyro_x, state.gyro_y, state.gyro_z,
+		state.accel_x, state.accel_y, state.accel_z, event.timestamp * 1000);
+	chiaki_orientation_tracker_apply_to_controller_state(&orientation_tracker, &state);
+	return true;
+}
+
+inline bool Controller::HandleTouchpadEvent(SDL_ControllerTouchpadEvent event)
+{
+	auto key = qMakePair(event.touchpad, event.finger);
+	bool exists = touch_ids.contains(key);
+	uint8_t chiaki_id;
+	switch(event.type)
+	{
+		case SDL_CONTROLLERTOUCHPADDOWN:
+			if(touch_ids.size() >= CHIAKI_CONTROLLER_TOUCHES_MAX)
+				return false;
+			chiaki_id = chiaki_controller_state_start_touch(&state, event.x * PS_TOUCHPAD_MAX_X, event.y * PS_TOUCHPAD_MAX_Y);
+			touch_ids.insert(key, chiaki_id);
+			break;
+		case SDL_CONTROLLERTOUCHPADMOTION:
+			if(!exists)
+				return false;
+			chiaki_controller_state_set_touch_pos(&state, touch_ids[key], event.x * PS_TOUCHPAD_MAX_X, event.y * PS_TOUCHPAD_MAX_Y);
+			break;
+		case SDL_CONTROLLERTOUCHPADUP:
+			if(!exists)
+				return false;
+			chiaki_controller_state_stop_touch(&state, touch_ids[key]);
+			touch_ids.remove(key);
+			break;
+		default:
+			return false;
+	}
+	return true;
+}
+#endif
+#endif
+
 bool Controller::IsConnected()
 {
 #ifdef CHIAKI_GUI_ENABLE_SDL_GAMECONTROLLER
@ -263,35 +476,6 @@ QString Controller::GetName()

 ChiakiControllerState Controller::GetState()
 {
-	ChiakiControllerState state;
-	chiaki_controller_state_set_idle(&state);
-#ifdef CHIAKI_GUI_ENABLE_SDL_GAMECONTROLLER
-	if(!controller)
-		return state;
-
-	state.buttons |= SDL_GameControllerGetButton(controller, SDL_CONTROLLER_BUTTON_A) ? CHIAKI_CONTROLLER_BUTTON_CROSS : 0;
-	state.buttons |= SDL_GameControllerGetButton(controller, SDL_CONTROLLER_BUTTON_B) ? CHIAKI_CONTROLLER_BUTTON_MOON : 0;
-	state.buttons |= SDL_GameControllerGetButton(controller, SDL_CONTROLLER_BUTTON_X) ? CHIAKI_CONTROLLER_BUTTON_BOX : 0;
-	state.buttons |= SDL_GameControllerGetButton(controller, SDL_CONTROLLER_BUTTON_Y) ? CHIAKI_CONTROLLER_BUTTON_PYRAMID : 0;
-	state.buttons |= SDL_GameControllerGetButton(controller, SDL_CONTROLLER_BUTTON_DPAD_LEFT) ? CHIAKI_CONTROLLER_BUTTON_DPAD_LEFT : 0;
-	state.buttons |= SDL_GameControllerGetButton(controller, SDL_CONTROLLER_BUTTON_DPAD_RIGHT) ? CHIAKI_CONTROLLER_BUTTON_DPAD_RIGHT : 0;
-	state.buttons |= SDL_GameControllerGetButton(controller, SDL_CONTROLLER_BUTTON_DPAD_UP) ? CHIAKI_CONTROLLER_BUTTON_DPAD_UP : 0;
-	state.buttons |= SDL_GameControllerGetButton(controller, SDL_CONTROLLER_BUTTON_DPAD_DOWN) ? CHIAKI_CONTROLLER_BUTTON_DPAD_DOWN : 0;
-	state.buttons |= SDL_GameControllerGetButton(controller, SDL_CONTROLLER_BUTTON_LEFTSHOULDER) ? CHIAKI_CONTROLLER_BUTTON_L1 : 0;
-	state.buttons |= SDL_GameControllerGetButton(controller, SDL_CONTROLLER_BUTTON_RIGHTSHOULDER) ? CHIAKI_CONTROLLER_BUTTON_R1 : 0;
-	state.buttons |= SDL_GameControllerGetButton(controller, SDL_CONTROLLER_BUTTON_LEFTSTICK) ? CHIAKI_CONTROLLER_BUTTON_L3 : 0;
-	state.buttons |= SDL_GameControllerGetButton(controller, SDL_CONTROLLER_BUTTON_RIGHTSTICK) ? CHIAKI_CONTROLLER_BUTTON_R3 : 0;
-	state.buttons |= SDL_GameControllerGetButton(controller, SDL_CONTROLLER_BUTTON_START) ? CHIAKI_CONTROLLER_BUTTON_OPTIONS : 0;
-	state.buttons |= SDL_GameControllerGetButton(controller, SDL_CONTROLLER_BUTTON_BACK) ? CHIAKI_CONTROLLER_BUTTON_SHARE : 0;
-	state.buttons |= SDL_GameControllerGetButton(controller, SDL_CONTROLLER_BUTTON_GUIDE) ? CHIAKI_CONTROLLER_BUTTON_PS : 0;
-	state.l2_state = (uint8_t)(SDL_GameControllerGetAxis(controller, SDL_CONTROLLER_AXIS_TRIGGERLEFT) >> 7);
-	state.r2_state = (uint8_t)(SDL_GameControllerGetAxis(controller, SDL_CONTROLLER_AXIS_TRIGGERRIGHT) >> 7);
-	state.left_x = SDL_GameControllerGetAxis(controller, SDL_CONTROLLER_AXIS_LEFTX);
-	state.left_y = SDL_GameControllerGetAxis(controller, SDL_CONTROLLER_AXIS_LEFTY);
-	state.right_x = SDL_GameControllerGetAxis(controller, SDL_CONTROLLER_AXIS_RIGHTX);
-	state.right_y = SDL_GameControllerGetAxis(controller, SDL_CONTROLLER_AXIS_RIGHTY);
-
-#endif
 	return state;
 }

--- a/lib/src/controller.c
+++ b/lib/src/controller.c
@ -121,6 +121,19 @@ CHIAKI_EXPORT void chiaki_controller_state_or(ChiakiControllerState *out, Chiaki
 	out->right_x = MAX_ABS(a->right_x, b->right_x);
 	out->right_y = MAX_ABS(a->right_y, b->right_y);

+	#define ORF(n, idle_val) if(a->n == idle_val) out->n = b->n; else out->n = a->n
+	ORF(accel_x, 0.0f);
+	ORF(accel_y, 1.0f);
+	ORF(accel_z, 0.0f);
+	ORF(gyro_x, 0.0f);
+	ORF(gyro_y, 0.0f);
+	ORF(gyro_z, 0.0f);
+	ORF(orient_x, 0.0f);
+	ORF(orient_y, 0.0f);
+	ORF(orient_z, 0.0f);
+	ORF(orient_w, 1.0f);
+	#undef ORF
+
 	out->touch_id_next = 0;
 	for(size_t i = 0; i < CHIAKI_CONTROLLER_TOUCHES_MAX; i++)
 	{
--- a/scripts/build-appimage.sh
+++ b/scripts/build-appimage.sh
@ -22,7 +22,6 @@ cmake \
 	-DCHIAKI_ENABLE_TESTS=ON \
 	-DCHIAKI_ENABLE_CLI=OFF \
 	-DCHIAKI_ENABLE_GUI=ON \
-	-DCHIAKI_ENABLE_SETSU=ON \
 	-DCHIAKI_GUI_ENABLE_SDL_GAMECONTROLLER=ON \
 	-DCMAKE_INSTALL_PREFIX=/usr \
 	..
--- a/scripts/build-sdl2.sh
+++ b/scripts/build-sdl2.sh
@ -6,9 +6,10 @@ cd $(dirname "${BASH_SOURCE[0]}")/..
 cd "./$1"
 ROOT="`pwd`"

-URL=https://www.libsdl.org/release/SDL2-2.0.10.tar.gz
-FILE=SDL2-2.0.10.tar.gz
-DIR=SDL2-2.0.10
+SDL_VER=2.26.1
+URL=https://www.libsdl.org/release/SDL2-${SDL_VER}.tar.gz
+FILE=SDL2-${SDL_VER}.tar.gz
+DIR=SDL2-${SDL_VER}

 if [ ! -d "$DIR" ]; then
 	curl -L "$URL" -O
--- a/scripts/run-podman-build-bullseye.sh
+++ b/scripts/run-podman-build-bullseye.sh
@ -9,7 +9,7 @@ podman run --rm -v "`pwd`:/build" chiaki-bullseye /bin/bash -c "
  cd /build &&
  rm -fv third-party/nanopb/generator/proto/nanopb_pb2.py &&
  mkdir build_bullseye &&
-  cmake -Bbuild_bullseye -GNinja -DCHIAKI_ENABLE_SETSU=ON -DCHIAKI_USE_SYSTEM_JERASURE=ON -DCHIAKI_USE_SYSTEM_NANOPB=ON &&
+  cmake -Bbuild_bullseye -GNinja -DCHIAKI_USE_SYSTEM_JERASURE=ON -DCHIAKI_USE_SYSTEM_NANOPB=ON &&
  ninja -C build_bullseye &&
  ninja -C build_bullseye test"