diff options
Diffstat (limited to 'Source/Core/InputCommon/ControllerInterface')
9 files changed, 1143 insertions, 1413 deletions
diff --git a/Source/Core/InputCommon/ControllerInterface/Android/Android.cpp b/Source/Core/InputCommon/ControllerInterface/Android/Android.cpp index 7a7c548cc6..a4bd7a3d46 100644 --- a/Source/Core/InputCommon/ControllerInterface/Android/Android.cpp +++ b/Source/Core/InputCommon/ControllerInterface/Android/Android.cpp @@ -1,32 +1,1142 @@ -// Copyright 2013 Dolphin Emulator Project +// Copyright 2021 Dolphin Emulator Project // SPDX-License-Identifier: GPL-2.0-or-later #include "InputCommon/ControllerInterface/Android/Android.h" +#include <algorithm> +#include <atomic> +#include <chrono> +#include <memory> +#include <string> +#include <unordered_map> +#include <utility> + +#include <fmt/format.h> + +#include <android/input.h> +#include <android/keycodes.h> +#include <jni.h> + +#include "Common/Assert.h" +#include "Common/Logging/Log.h" +#include "Common/StringUtil.h" + #include "InputCommon/ControllerInterface/ControllerInterface.h" -#include "InputCommon/ControllerInterface/Touch/Touchscreen.h" + +#include "jni/AndroidCommon/AndroidCommon.h" +#include "jni/AndroidCommon/IDCache.h" +#include "jni/Input/CoreDevice.h" + +namespace +{ +jclass s_list_class; +jmethodID s_list_get; +jmethodID s_list_size; + +jclass s_input_device_class; +jmethodID s_input_device_get_device_ids; +jmethodID s_input_device_get_device; +jmethodID s_input_device_get_controller_number; +jmethodID s_input_device_get_id; +jmethodID s_input_device_get_motion_ranges; +jmethodID s_input_device_get_name; +jmethodID s_input_device_get_sources; +jmethodID s_input_device_has_keys; + +jclass s_motion_range_class; +jmethodID s_motion_range_get_axis; +jmethodID s_motion_range_get_max; +jmethodID s_motion_range_get_min; +jmethodID s_motion_range_get_source; + +jclass s_input_event_class; +jmethodID s_input_event_get_device; + +jclass s_key_event_class; +jmethodID s_key_event_get_action; +jmethodID s_key_event_get_keycode; + +jclass s_motion_event_class; +jmethodID s_motion_event_get_axis_value; +jmethodID s_motion_event_get_source; + +jclass s_controller_interface_class; +jmethodID s_controller_interface_register_input_device_listener; +jmethodID s_controller_interface_unregister_input_device_listener; +jmethodID s_controller_interface_get_vibrator_manager; +jmethodID s_controller_interface_get_system_vibrator_manager; +jmethodID s_controller_interface_vibrate; + +jclass s_sensor_event_listener_class; +jmethodID s_sensor_event_listener_constructor; +jmethodID s_sensor_event_listener_constructor_input_device; +jmethodID s_sensor_event_listener_set_device_qualifier; +jmethodID s_sensor_event_listener_request_unsuspend_sensor; +jmethodID s_sensor_event_listener_get_axis_names; +jmethodID s_sensor_event_listener_get_negative_axes; + +jclass s_dolphin_vibrator_manager_class; +jmethodID s_dolphin_vibrator_manager_get_vibrator; +jmethodID s_dolphin_vibrator_manager_get_vibrator_ids; + +jintArray s_keycodes_array; + +using Clock = std::chrono::steady_clock; +constexpr Clock::duration ACTIVE_INPUT_TIMEOUT = std::chrono::milliseconds(1000); + +std::unordered_map<jint, ciface::Core::DeviceQualifier> s_device_id_to_device_qualifier; + +constexpr int MAX_KEYCODE = AKEYCODE_PROFILE_SWITCH; // Up to date as of SDK 31 + +const std::array<std::string_view, MAX_KEYCODE + 1> KEYCODE_NAMES = { + "Unknown", + "Soft Left", + "Soft Right", + "Home", + "Back", + "Call", + "End Call", + "0", + "1", + "2", + "3", + "4", + "5", + "6", + "7", + "8", + "9", + "Star", + "Pound", + "Up", + "Down", + "Left", + "Right", + "Center", + "Volume Up", + "Volume Down", + "Power", + "Camera", + "Clear", + "A", + "B", + "C", + "D", + "E", + "F", + "G", + "H", + "I", + "J", + "K", + "L", + "M", + "N", + "O", + "P", + "Q", + "R", + "S", + "T", + "U", + "V", + "W", + "X", + "Y", + "Z", + "Comma", + "Period", + "Left Alt", + "Right Alt", + "Left Shift", + "Right Shift", + "Tab", + "Space", + "Sym", + "Explorer", + "Envelope", + "Enter", + "Backspace", + "Grave", + "Minus", + "Equals", + "Left Bracket", + "Right Bracket", + "Backslash", + "Semicolon", + "Apostrophe", + "Slash", + "At", + "Num", + "Headset Hook", + "Focus", + "Plus", + "Menu", + "Notification", + "Search", + "Play Pause", + "Stop", + "Next", + "Previous", + "Rewind", + "Fast Forward", + "Mute", + "Page Up", + "Page Down", + "Emoji", + "Switch Charset", + "Button A", + "Button B", + "Button C", + "Button X", + "Button Y", + "Button Z", + "Button L1", + "Button R1", + "Button L2", + "Button R2", + "Button L3", + "Button R3", + "Start", + "Select", + "Mode", + "Escape", + "Delete", + "Left Ctrl", + "Right Ctrl", + "Caps Lock", + "Scroll Lock", + "Left Meta", + "Right Meta", + "Fn", + "PrtSc SysRq", + "Pause Break", + "Move Home", + "Move End", + "Insert", + "Forward", + "Play", + "Pause", + "Close", + "Eject", + "Record", + "F1", + "F2", + "F3", + "F4", + "F5", + "F6", + "F7", + "F8", + "F9", + "F10", + "F11", + "F12", + "Num Lock", + "Numpad 0", + "Numpad 1", + "Numpad 2", + "Numpad 3", + "Numpad 4", + "Numpad 5", + "Numpad 6", + "Numpad 7", + "Numpad 8", + "Numpad 9", + "Numpad Divide", + "Numpad Multiply", + "Numpad Subtract", + "Numpad Add", + "Numpad Dot", + "Numpad Comma", + "Numpad Enter", + "Numpad Equals", + "Numpad Left Paren", + "Numpad Right Paren", + "Volume Mute", + "Info", + "Channel Up", + "Channel Down", + "Zoom In", + "Zoom Out", + "TV", + "Window", + "Guide", + "DVR", + "Bookmark", + "Captions", + "Settings", + "TV Power", + "TV Input", + "STB Power", + "STB Input", + "AVR Power", + "AVR Input", + "Prog Red", + "Prog Green", + "Prog Yellow", + "Prog Blue", + "App Switch", + "Button 1", + "Button 2", + "Button 3", + "Button 4", + "Button 5", + "Button 6", + "Button 7", + "Button 8", + "Button 9", + "Button 10", + "Button 11", + "Button 12", + "Button 13", + "Button 14", + "Button 15", + "Button 16", + "Language Switch", + "Manner Mode", + "3D Mode", + "Contacts", + "Calendar", + "Music", + "Calculator", + "Zenkaku Hankaku", + "Eisu", + "Henkan", + "Muhenkan", + "Katakana Hiragana", + "Yen", + "Ro", + "Kana", + "Assist", + "Brightness Down", + "Brightness Up", + "Audio Track", + "Sleep", + "Wakeup", + "Pairing", + "Top Menu", + "11", + "12", + "Last Channel", + "Data Service", + "Voice Assist", + "Radio Service", + "Teletext", + "Number Entry", + "Terrestrial Analog", + "Terrestrial Digital", + "Satellite", + "Satellite BS", + "Satellite CS", + "Satellite Service", + "Network", + "Antenna Cable", + "Input HDMI 1", + "Input HDMI 2", + "Input HDMI 3", + "Input HDMI 4", + "Input Composite 1", + "Input Composite 2", + "Input Component 1", + "Input Component 2", + "Input VGA 1", + "Audio Description", + "Audio Description Mix Up", + "Audio Description Mix Down", + "Zoom Mode", + "Contents Menu", + "Media Context Menu", + "Timer Programming", + "Help", + "Navigate Previous", + "Navigate Next", + "Navigate In", + "Navigate Out", + "Stem Primary", + "Stem 1", + "Stem 2", + "Stem 3", + "Up Left", + "Down Left", + "Up Right", + "Down Right", + "Skip Forward", + "Skip Backward", + "Step Forward", + "Step Backward", + "Soft Sleep", + "Cut", + "Copy", + "Paste", + "System Navigation Up", + "System Navigation Down", + "System Navigation Left", + "System Navigation Right", + "All Apps", + "Refresh", + "Thumbs Up", + "Thumbs Down", + "Profile Switch", +}; + +std::string ConstructKeyName(int keycode) +{ + return std::string(KEYCODE_NAMES[keycode]); +} + +std::string ConstructAxisNamePrefix(int source) +{ + // A device is allowed to have two axes with the same axis ID but different source IDs, + // so we have to make sure to include the source in the axis name. + + static const std::unordered_map<int, std::string> source_names{ + {AINPUT_SOURCE_KEYBOARD, "Keyboard"}, + {AINPUT_SOURCE_DPAD, "Dpad"}, + {AINPUT_SOURCE_GAMEPAD, "Gamepad"}, + {AINPUT_SOURCE_TOUCHSCREEN, "Touch"}, + {AINPUT_SOURCE_MOUSE, "Cursor"}, + {AINPUT_SOURCE_STYLUS, "Stylus"}, + {AINPUT_SOURCE_BLUETOOTH_STYLUS, "BTStylus"}, + {AINPUT_SOURCE_TRACKBALL, "Trackball"}, + {AINPUT_SOURCE_MOUSE_RELATIVE, "Mouse"}, + {AINPUT_SOURCE_TOUCHPAD, "Touchpad"}, + {AINPUT_SOURCE_TOUCH_NAVIGATION, "Touchnav"}, + {AINPUT_SOURCE_JOYSTICK, "Axis"}, // The typical source for all axes on a gamepad + {AINPUT_SOURCE_HDMI, "HDMI"}, + {AINPUT_SOURCE_SENSOR, "Sensor"}, + {AINPUT_SOURCE_ROTARY_ENCODER, "Rotary"}, + }; + + const auto it = source_names.find(source); + if (it != source_names.end()) + return fmt::format("{} ", it->second); + else + return fmt::format("Axis {:08x}/", source); +} + +std::string ConstructAxisName(int source, int axis, bool negative) +{ + const char sign = negative ? '-' : '+'; + return fmt::format("{}{}{}", ConstructAxisNamePrefix(source), axis, sign); +} + +std::shared_ptr<ciface::Core::Device> FindDevice(jint device_id) +{ + const auto it = s_device_id_to_device_qualifier.find(device_id); + if (it == s_device_id_to_device_qualifier.end()) + { + ERROR_LOG_FMT(CONTROLLERINTERFACE, "Could not find device ID {}", device_id); + return nullptr; + } + + const ciface::Core::DeviceQualifier& qualifier = it->second; + std::shared_ptr<ciface::Core::Device> device = g_controller_interface.FindDevice(qualifier); + if (!device) + { + ERROR_LOG_FMT(CONTROLLERINTERFACE, "Could not find device {}", qualifier.ToString()); + return nullptr; + } + + return device; +} + +} // namespace namespace ciface::Android { -static bool s_accelerometer_enabled = false; -static bool s_gyroscope_enabled = false; +class AndroidInput : public Core::Device::Input +{ +public: + explicit AndroidInput(std::string name) : m_name(std::move(name)) + { + DEBUG_LOG_FMT(CONTROLLERINTERFACE, "Created {}", m_name); + } + + std::string GetName() const override { return m_name; } + + ControlState GetState() const override + { + m_last_polled.store(Clock::now(), std::memory_order_relaxed); + return m_state.load(std::memory_order_relaxed); + } + + void SetState(ControlState state) { m_state.store(state, std::memory_order_relaxed); } + + Clock::time_point GetLastPolled() const { return m_last_polled.load(std::memory_order_relaxed); } + +private: + std::string m_name; + std::atomic<ControlState> m_state = 0; + mutable std::atomic<Clock::time_point> m_last_polled{}; +}; + +class AndroidKey final : public AndroidInput +{ +public: + explicit AndroidKey(int keycode) : AndroidInput(ConstructKeyName(keycode)) {} +}; + +class AndroidAxis : public AndroidInput +{ +public: + AndroidAxis(int source, int axis, bool negative) + : AndroidInput(ConstructAxisName(source, axis, negative)), m_negative(negative) + { + } + + AndroidAxis(std::string name, bool negative) : AndroidInput(std::move(name)), m_negative(negative) + { + } + + ControlState GetState() const override + { + return m_negative ? -AndroidInput::GetState() : AndroidInput::GetState(); + } + +private: + bool m_negative; +}; + +class AndroidSensorAxis final : public AndroidAxis +{ +public: + // This class does not create its own global reference to the passed-in sensor_event_listener. + // That is, it's up to the device that contains this axis to keep sensor_event_listener valid. + // It does however create its own global reference to the passed-in name. + AndroidSensorAxis(JNIEnv* env, jobject sensor_event_listener, jstring j_name, bool negative) + : AndroidAxis(GetJString(env, j_name), negative), + m_sensor_event_listener(sensor_event_listener), + m_j_name(reinterpret_cast<jstring>(env->NewGlobalRef(j_name))) + { + } + + ~AndroidSensorAxis() { IDCache::GetEnvForThread()->DeleteGlobalRef(m_j_name); } + + bool IsDetectable() const override { return false; } + + ControlState GetState() const override + { + if (m_is_suspended.load(std::memory_order_relaxed)) + { + IDCache::GetEnvForThread()->CallVoidMethod( + m_sensor_event_listener, s_sensor_event_listener_request_unsuspend_sensor, m_j_name); + + // m_is_suspended is intentionally not updated here. To prevent the C++ suspended status from + // ending up desynced with the Java suspended status, we only update m_is_suspended when Java + // calls notifySensorSuspendedState (which calls NotifyIsSuspended). This way, Java is the + // authoritative source for the suspended status, and C++ mirrors it (possibly with a delay). + } + + return AndroidAxis::GetState(); + } + + void NotifyIsSuspended(bool is_suspended) + { + m_is_suspended.store(is_suspended, std::memory_order_relaxed); + } + +private: + const jobject m_sensor_event_listener; + const jstring m_j_name; + std::atomic<bool> m_is_suspended = true; +}; + +class AndroidMotor : public Core::Device::Output +{ +public: + AndroidMotor(JNIEnv* env, jobject vibrator, jint id) + : m_vibrator(env->NewGlobalRef(vibrator)), m_id(id) + { + } + + ~AndroidMotor() { IDCache::GetEnvForThread()->DeleteGlobalRef(m_vibrator); } + + std::string GetName() const override { return "Motor " + std::to_string(m_id); } + + void SetState(ControlState state) override + { + ControlState old_state = m_state.exchange(state, std::memory_order_relaxed); + + if (old_state < 0.5 && state >= 0.5) + { + IDCache::GetEnvForThread()->CallStaticVoidMethod(s_controller_interface_class, + s_controller_interface_vibrate, m_vibrator); + } + } + +private: + const jobject m_vibrator; + const jint m_id; + std::atomic<ControlState> m_state = 0; +}; + +class AndroidDevice final : public Core::Device +{ +public: + AndroidDevice(JNIEnv* env, jobject input_device) + : m_sensor_event_listener(AddSensors(env, input_device)), + m_source(env->CallIntMethod(input_device, s_input_device_get_sources)), + m_controller_number(env->CallIntMethod(input_device, s_input_device_get_controller_number)) + { + jstring j_name = + reinterpret_cast<jstring>(env->CallObjectMethod(input_device, s_input_device_get_name)); + m_name = GetJString(env, j_name); + env->DeleteLocalRef(j_name); + + DEBUG_LOG_FMT(CONTROLLERINTERFACE, "Sources for {}: {:08x}", GetQualifiedName(), m_source); + + AddKeys(env, input_device); + AddAxes(env, input_device); + AddMotors(env, input_device); + } + + // Constructor for the device added by Dolphin to contain sensor inputs + AndroidDevice(JNIEnv* env, std::string name) + : m_sensor_event_listener(AddSensors(env, nullptr)), m_source(AINPUT_SOURCE_SENSOR), + m_controller_number(0), m_name(std::move(name)) + { + AddSystemMotors(env); + } + + ~AndroidDevice() + { + if (m_sensor_event_listener) + IDCache::GetEnvForThread()->DeleteGlobalRef(m_sensor_event_listener); + } + + std::string GetName() const override { return m_name; } + + std::string GetSource() const override { return "Android"; } + + std::optional<int> GetPreferredId() const override + { + return m_controller_number != 0 ? std::make_optional(m_controller_number) : std::nullopt; + } + + int GetSortPriority() const override + { + // If m_controller_number is non-zero, Android considers this to be a gamepad + if (m_controller_number != 0) + return 0; + + if ((m_source & AINPUT_SOURCE_KEYBOARD) != 0) + return -1; + + if ((m_source & (AINPUT_SOURCE_MOUSE | AINPUT_SOURCE_MOUSE_RELATIVE)) != 0) + return -2; + + return -3; + } + + jobject GetSensorEventListener() { return m_sensor_event_listener; } + +private: + void AddKeys(JNIEnv* env, jobject input_device) + { + jbooleanArray keys_array = reinterpret_cast<jbooleanArray>( + env->CallObjectMethod(input_device, s_input_device_has_keys, s_keycodes_array)); + jboolean* keys = env->GetBooleanArrayElements(keys_array, nullptr); + jsize keys_count = env->GetArrayLength(keys_array); + for (jsize i = 0; i < keys_count; ++i) + { + // These specific keys never get delivered to applications, + // so there's no point in letting users try to map them + if (i == AKEYCODE_HOME || i == AKEYCODE_ASSIST || i == AKEYCODE_VOICE_ASSIST) + continue; + + if (keys[i]) + AddInput(new AndroidKey(i)); + } + env->ReleaseBooleanArrayElements(keys_array, keys, JNI_ABORT); + env->DeleteLocalRef(keys_array); + } + + void AddAxes(JNIEnv* env, jobject input_device) + { + jobject motion_ranges_list = + env->CallObjectMethod(input_device, s_input_device_get_motion_ranges); + jint motion_ranges_count = env->CallIntMethod(motion_ranges_list, s_list_size); + for (jint i = 0; i < motion_ranges_count; ++i) + { + jobject motion_range = env->CallObjectMethod(motion_ranges_list, s_list_get, i); + + jint source = env->CallIntMethod(motion_range, s_motion_range_get_source); + jint axis = env->CallIntMethod(motion_range, s_motion_range_get_axis); + jfloat min = env->CallFloatMethod(motion_range, s_motion_range_get_min); + jfloat max = env->CallFloatMethod(motion_range, s_motion_range_get_max); + + env->DeleteLocalRef(motion_range); + + AndroidAxis* positive = nullptr; + AndroidAxis* negative = nullptr; + if (max > 0) + positive = new AndroidAxis(source, axis, false); + if (min < 0) + negative = new AndroidAxis(source, axis, true); + + if (positive && negative) + AddAnalogInputs(positive, negative); + else if (positive || negative) + AddInput(positive ? positive : negative); + } + env->DeleteLocalRef(motion_ranges_list); + } + + jobject AddSensors(JNIEnv* env, jobject input_device) + { + jobject local_sensor_event_listener; + if (input_device) + { + local_sensor_event_listener = + env->NewObject(s_sensor_event_listener_class, + s_sensor_event_listener_constructor_input_device, input_device); + } + else + { + local_sensor_event_listener = + env->NewObject(s_sensor_event_listener_class, s_sensor_event_listener_constructor); + } + + jobject sensor_event_listener = env->NewGlobalRef(local_sensor_event_listener); + + env->DeleteLocalRef(local_sensor_event_listener); + + jobjectArray j_axis_names = reinterpret_cast<jobjectArray>( + env->CallObjectMethod(sensor_event_listener, s_sensor_event_listener_get_axis_names)); + + jbooleanArray j_negative_axes = reinterpret_cast<jbooleanArray>( + env->CallObjectMethod(sensor_event_listener, s_sensor_event_listener_get_negative_axes)); + jboolean* negative_axes = env->GetBooleanArrayElements(j_negative_axes, nullptr); + + const jsize axis_count = env->GetArrayLength(j_axis_names); + ASSERT(axis_count == env->GetArrayLength(j_negative_axes)); + for (jsize i = 0; i < axis_count; ++i) + { + const jstring axis_name = + reinterpret_cast<jstring>(env->GetObjectArrayElement(j_axis_names, i)); + AddInput(new AndroidSensorAxis(env, sensor_event_listener, axis_name, negative_axes[i])); + env->DeleteLocalRef(axis_name); + } + + env->DeleteLocalRef(j_axis_names); + env->ReleaseBooleanArrayElements(j_negative_axes, negative_axes, 0); + env->DeleteLocalRef(j_negative_axes); + + return sensor_event_listener; + } + + void AddMotors(JNIEnv* env, jobject input_device) + { + jobject vibrator_manager = env->CallStaticObjectMethod( + s_controller_interface_class, s_controller_interface_get_vibrator_manager, input_device); + AddMotorsFromManager(env, vibrator_manager); + env->DeleteLocalRef(vibrator_manager); + } + + void AddSystemMotors(JNIEnv* env) + { + jobject vibrator_manager = env->CallStaticObjectMethod( + s_controller_interface_class, s_controller_interface_get_system_vibrator_manager); + AddMotorsFromManager(env, vibrator_manager); + env->DeleteLocalRef(vibrator_manager); + } + + void AddMotorsFromManager(JNIEnv* env, jobject vibrator_manager) + { + jintArray j_vibrator_ids = reinterpret_cast<jintArray>( + env->CallObjectMethod(vibrator_manager, s_dolphin_vibrator_manager_get_vibrator_ids)); + jint* vibrator_ids = env->GetIntArrayElements(j_vibrator_ids, nullptr); + + jint size = env->GetArrayLength(j_vibrator_ids); + for (jint i = 0; i < size; ++i) + { + jobject vibrator = + env->CallObjectMethod(vibrator_manager, s_dolphin_vibrator_manager_get_vibrator, i); + AddOutput(new AndroidMotor(env, vibrator, i)); + env->DeleteLocalRef(vibrator); + } + + env->ReleaseIntArrayElements(j_vibrator_ids, vibrator_ids, 0); + env->DeleteLocalRef(j_vibrator_ids); + } + + const jobject m_sensor_event_listener; + const int m_source; + const int m_controller_number; + std::string m_name; +}; + +// Creates an array that contains every possible keycode +static jintArray CreateKeyCodesArray(JNIEnv* env) +{ + jintArray keycodes_array = env->NewIntArray(MAX_KEYCODE + 1); + + int* keycodes = env->GetIntArrayElements(keycodes_array, nullptr); + for (int i = 0; i <= MAX_KEYCODE; ++i) + keycodes[i] = i; + env->ReleaseIntArrayElements(keycodes_array, keycodes, 0); + + return keycodes_array; +} -void SetMotionSensorsEnabled(bool accelerometer_enabled, bool gyroscope_enabled) +void Init() { - const bool any_changes = - s_accelerometer_enabled != accelerometer_enabled || s_gyroscope_enabled != gyroscope_enabled; + JNIEnv* env = IDCache::GetEnvForThread(); + + const jclass list_class = env->FindClass("java/util/List"); + s_list_class = reinterpret_cast<jclass>(env->NewGlobalRef(list_class)); + s_list_get = env->GetMethodID(s_list_class, "get", "(I)Ljava/lang/Object;"); + s_list_size = env->GetMethodID(s_list_class, "size", "()I"); + env->DeleteLocalRef(list_class); + + const jclass input_device_class = env->FindClass("android/view/InputDevice"); + s_input_device_class = reinterpret_cast<jclass>(env->NewGlobalRef(input_device_class)); + s_input_device_get_device_ids = + env->GetStaticMethodID(s_input_device_class, "getDeviceIds", "()[I"); + s_input_device_get_device = + env->GetStaticMethodID(s_input_device_class, "getDevice", "(I)Landroid/view/InputDevice;"); + s_input_device_get_controller_number = + env->GetMethodID(s_input_device_class, "getControllerNumber", "()I"); + s_input_device_get_id = env->GetMethodID(s_input_device_class, "getId", "()I"); + s_input_device_get_motion_ranges = + env->GetMethodID(s_input_device_class, "getMotionRanges", "()Ljava/util/List;"); + s_input_device_get_name = + env->GetMethodID(s_input_device_class, "getName", "()Ljava/lang/String;"); + s_input_device_get_sources = env->GetMethodID(s_input_device_class, "getSources", "()I"); + s_input_device_has_keys = env->GetMethodID(s_input_device_class, "hasKeys", "([I)[Z"); + env->DeleteLocalRef(input_device_class); + + const jclass motion_range_class = env->FindClass("android/view/InputDevice$MotionRange"); + s_motion_range_class = reinterpret_cast<jclass>(env->NewGlobalRef(motion_range_class)); + s_motion_range_get_axis = env->GetMethodID(s_motion_range_class, "getAxis", "()I"); + s_motion_range_get_max = env->GetMethodID(s_motion_range_class, "getMax", "()F"); + s_motion_range_get_min = env->GetMethodID(s_motion_range_class, "getMin", "()F"); + s_motion_range_get_source = env->GetMethodID(s_motion_range_class, "getSource", "()I"); + env->DeleteLocalRef(motion_range_class); + + const jclass input_event_class = env->FindClass("android/view/InputEvent"); + s_input_event_class = reinterpret_cast<jclass>(env->NewGlobalRef(input_event_class)); + s_input_event_get_device = + env->GetMethodID(s_input_event_class, "getDevice", "()Landroid/view/InputDevice;"); + + const jclass key_event_class = env->FindClass("android/view/KeyEvent"); + s_key_event_class = reinterpret_cast<jclass>(env->NewGlobalRef(key_event_class)); + s_key_event_get_action = env->GetMethodID(s_key_event_class, "getAction", "()I"); + s_key_event_get_keycode = env->GetMethodID(s_key_event_class, "getKeyCode", "()I"); - s_accelerometer_enabled = accelerometer_enabled; - s_gyroscope_enabled = gyroscope_enabled; + const jclass motion_event_class = env->FindClass("android/view/MotionEvent"); + s_motion_event_class = reinterpret_cast<jclass>(env->NewGlobalRef(motion_event_class)); + s_motion_event_get_axis_value = env->GetMethodID(s_motion_event_class, "getAxisValue", "(I)F"); + s_motion_event_get_source = env->GetMethodID(s_motion_event_class, "getSource", "()I"); - if (any_changes) - g_controller_interface.RefreshDevices(); + const jclass controller_interface_class = + env->FindClass("org/dolphinemu/dolphinemu/features/input/model/ControllerInterface"); + s_controller_interface_class = + reinterpret_cast<jclass>(env->NewGlobalRef(controller_interface_class)); + s_controller_interface_register_input_device_listener = + env->GetStaticMethodID(s_controller_interface_class, "registerInputDeviceListener", "()V"); + s_controller_interface_unregister_input_device_listener = + env->GetStaticMethodID(s_controller_interface_class, "unregisterInputDeviceListener", "()V"); + s_controller_interface_get_vibrator_manager = + env->GetStaticMethodID(s_controller_interface_class, "getVibratorManager", + "(Landroid/view/InputDevice;)Lorg/dolphinemu/dolphinemu/features/" + "input/model/DolphinVibratorManager;"); + s_controller_interface_get_system_vibrator_manager = env->GetStaticMethodID( + s_controller_interface_class, "getSystemVibratorManager", + "()Lorg/dolphinemu/dolphinemu/features/input/model/DolphinVibratorManager;"); + s_controller_interface_vibrate = + env->GetStaticMethodID(s_controller_interface_class, "vibrate", "(Landroid/os/Vibrator;)V"); + + const jclass sensor_event_listener_class = + env->FindClass("org/dolphinemu/dolphinemu/features/input/model/DolphinSensorEventListener"); + s_sensor_event_listener_class = + reinterpret_cast<jclass>(env->NewGlobalRef(sensor_event_listener_class)); + s_sensor_event_listener_constructor = + env->GetMethodID(s_sensor_event_listener_class, "<init>", "()V"); + s_sensor_event_listener_constructor_input_device = + env->GetMethodID(s_sensor_event_listener_class, "<init>", "(Landroid/view/InputDevice;)V"); + s_sensor_event_listener_set_device_qualifier = env->GetMethodID( + s_sensor_event_listener_class, "setDeviceQualifier", "(Ljava/lang/String;)V"); + s_sensor_event_listener_request_unsuspend_sensor = env->GetMethodID( + s_sensor_event_listener_class, "requestUnsuspendSensor", "(Ljava/lang/String;)V"); + s_sensor_event_listener_get_axis_names = + env->GetMethodID(s_sensor_event_listener_class, "getAxisNames", "()[Ljava/lang/String;"); + s_sensor_event_listener_get_negative_axes = + env->GetMethodID(s_sensor_event_listener_class, "getNegativeAxes", "()[Z"); + + const jclass dolphin_vibrator_manager_class = + env->FindClass("org/dolphinemu/dolphinemu/features/input/model/DolphinVibratorManager"); + s_dolphin_vibrator_manager_class = + reinterpret_cast<jclass>(env->NewGlobalRef(dolphin_vibrator_manager_class)); + s_dolphin_vibrator_manager_get_vibrator = + env->GetMethodID(s_dolphin_vibrator_manager_class, "getVibrator", "(I)Landroid/os/Vibrator;"); + s_dolphin_vibrator_manager_get_vibrator_ids = + env->GetMethodID(s_dolphin_vibrator_manager_class, "getVibratorIds", "()[I"); + + jintArray keycodes_array = CreateKeyCodesArray(env); + s_keycodes_array = reinterpret_cast<jintArray>(env->NewGlobalRef(keycodes_array)); + env->DeleteLocalRef(keycodes_array); + + env->CallStaticVoidMethod(s_controller_interface_class, + s_controller_interface_register_input_device_listener); +} + +void Shutdown() +{ + JNIEnv* env = IDCache::GetEnvForThread(); + + env->CallStaticVoidMethod(s_controller_interface_class, + s_controller_interface_unregister_input_device_listener); + + env->DeleteGlobalRef(s_input_device_class); + env->DeleteGlobalRef(s_motion_range_class); + env->DeleteGlobalRef(s_input_event_class); + env->DeleteGlobalRef(s_key_event_class); + env->DeleteGlobalRef(s_motion_event_class); + env->DeleteGlobalRef(s_controller_interface_class); + env->DeleteGlobalRef(s_sensor_event_listener_class); + env->DeleteGlobalRef(s_dolphin_vibrator_manager_class); + env->DeleteGlobalRef(s_keycodes_array); +} + +static void AddDevice(JNIEnv* env, int device_id) +{ + jobject input_device = + env->CallStaticObjectMethod(s_input_device_class, s_input_device_get_device, device_id); + + auto device = std::make_shared<AndroidDevice>(env, input_device); + + env->DeleteLocalRef(input_device); + + if (device->Inputs().empty() && device->Outputs().empty()) + return; + + g_controller_interface.AddDevice(device); + + Core::DeviceQualifier qualifier; + qualifier.FromDevice(device.get()); + + INFO_LOG_FMT(CONTROLLERINTERFACE, "Added device ID {} as {}", device_id, + device->GetQualifiedName()); + s_device_id_to_device_qualifier.emplace(device_id, qualifier); + + jstring j_qualifier = ToJString(env, qualifier.ToString()); + env->CallVoidMethod(device->GetSensorEventListener(), + s_sensor_event_listener_set_device_qualifier, j_qualifier); + env->DeleteLocalRef(j_qualifier); +} + +static void AddSensorDevice(JNIEnv* env) +{ + // Device sensors (accelerometer, etc.) aren't associated with any Android InputDevice. + // Create an otherwise empty Dolphin input device so that they have somewhere to live. + + auto device = std::make_shared<AndroidDevice>(env, "Device Sensors"); + + if (device->Inputs().empty() && device->Outputs().empty()) + return; + + g_controller_interface.AddDevice(device); + + Core::DeviceQualifier qualifier; + qualifier.FromDevice(device.get()); + + INFO_LOG_FMT(CONTROLLERINTERFACE, "Added sensor device as {}", device->GetQualifiedName()); + + jstring j_qualifier = ToJString(env, qualifier.ToString()); + env->CallVoidMethod(device->GetSensorEventListener(), + s_sensor_event_listener_set_device_qualifier, j_qualifier); + env->DeleteLocalRef(j_qualifier); } void PopulateDevices() { - for (int i = 0; i < 8; ++i) - g_controller_interface.AddDevice(std::make_shared<ciface::Touch::Touchscreen>( - i, s_accelerometer_enabled, s_gyroscope_enabled)); + INFO_LOG_FMT(CONTROLLERINTERFACE, "Android populating devices"); + + JNIEnv* env = IDCache::GetEnvForThread(); + + jintArray device_ids_array = reinterpret_cast<jintArray>( + env->CallStaticObjectMethod(s_input_device_class, s_input_device_get_device_ids)); + int* device_ids = env->GetIntArrayElements(device_ids_array, nullptr); + jsize device_ids_count = env->GetArrayLength(device_ids_array); + for (jsize i = 0; i < device_ids_count; ++i) + AddDevice(env, device_ids[i]); + env->ReleaseIntArrayElements(device_ids_array, device_ids, JNI_ABORT); + env->DeleteLocalRef(device_ids_array); + + AddSensorDevice(env); } + } // namespace ciface::Android + +extern "C" { + +JNIEXPORT jboolean JNICALL +Java_org_dolphinemu_dolphinemu_features_input_model_ControllerInterface_dispatchKeyEvent( + JNIEnv* env, jclass, jobject key_event) +{ + const jint action = env->CallIntMethod(key_event, s_key_event_get_action); + ControlState state; + switch (action) + { + case AKEY_EVENT_ACTION_DOWN: + state = 1; + break; + case AKEY_EVENT_ACTION_UP: + state = 0; + break; + default: + return JNI_FALSE; + } + + const jobject input_device = env->CallObjectMethod(key_event, s_input_event_get_device); + const jint device_id = env->CallIntMethod(input_device, s_input_device_get_id); + env->DeleteLocalRef(input_device); + const std::shared_ptr<ciface::Core::Device> device = FindDevice(device_id); + if (!device) + return JNI_FALSE; + + const jint keycode = env->CallIntMethod(key_event, s_key_event_get_keycode); + const std::string input_name = ConstructKeyName(keycode); + + ciface::Core::Device::Input* input = device->FindInput(input_name); + if (!input) + { + ERROR_LOG_FMT(CONTROLLERINTERFACE, "Could not find input {} in device {}", input_name, + device->GetQualifiedName()); + return false; + } + + auto casted_input = static_cast<ciface::Android::AndroidInput*>(input); + casted_input->SetState(state); + const Clock::time_point last_polled = casted_input->GetLastPolled(); + + DEBUG_LOG_FMT(CONTROLLERINTERFACE, "Set {} of {} to {}", input_name, device->GetQualifiedName(), + state); + + return last_polled >= Clock::now() - ACTIVE_INPUT_TIMEOUT; +} + +JNIEXPORT jboolean JNICALL +Java_org_dolphinemu_dolphinemu_features_input_model_ControllerInterface_dispatchGenericMotionEvent( + JNIEnv* env, jclass, jobject motion_event) +{ + const jobject input_device = env->CallObjectMethod(motion_event, s_input_event_get_device); + const jint device_id = env->CallIntMethod(input_device, s_input_device_get_id); + env->DeleteLocalRef(input_device); + const std::shared_ptr<ciface::Core::Device> device = FindDevice(device_id); + if (!device) + return JNI_FALSE; + + const jint source = env->CallIntMethod(motion_event, s_motion_event_get_source); + const std::string axis_name_prefix = ConstructAxisNamePrefix(source); + + Clock::time_point last_polled{}; + + for (ciface::Core::Device::Input* input : device->Inputs()) + { + const std::string input_name = input->GetName(); + if (input_name.starts_with(axis_name_prefix)) + { + const std::string axis_id_str = input_name.substr( + axis_name_prefix.size(), input_name.size() - axis_name_prefix.size() - sizeof('+')); + + int axis_id; + if (!TryParse(axis_id_str, &axis_id)) + { + ERROR_LOG_FMT(CONTROLLERINTERFACE, "Failed to parse \"{}\" from \"{}\" as axis ID", + axis_id_str, input_name); + continue; + } + + float value = env->CallFloatMethod(motion_event, s_motion_event_get_axis_value, axis_id); + + auto casted_input = static_cast<ciface::Android::AndroidInput*>(input); + casted_input->SetState(value); + last_polled = std::max(last_polled, casted_input->GetLastPolled()); + + DEBUG_LOG_FMT(CONTROLLERINTERFACE, "Set {} of {} to {}", input_name, + device->GetQualifiedName(), value); + } + } + + return last_polled >= Clock::now() - ACTIVE_INPUT_TIMEOUT; +} + +JNIEXPORT jboolean JNICALL +Java_org_dolphinemu_dolphinemu_features_input_model_ControllerInterface_dispatchSensorEvent( + JNIEnv* env, jclass, jstring j_device_qualifier, jstring j_axis_name, jfloat value) +{ + ciface::Core::DeviceQualifier device_qualifier; + device_qualifier.FromString(GetJString(env, j_device_qualifier)); + const std::shared_ptr<ciface::Core::Device> device = + g_controller_interface.FindDevice(device_qualifier); + if (!device) + return JNI_FALSE; + + const std::string axis_name = GetJString(env, j_axis_name); + + Clock::time_point last_polled{}; + + for (ciface::Core::Device::Input* input : device->Inputs()) + { + const std::string input_name = input->GetName(); + if (input_name == axis_name) + { + auto casted_input = static_cast<ciface::Android::AndroidInput*>(input); + casted_input->SetState(value); + last_polled = std::max(last_polled, casted_input->GetLastPolled()); + } + } + + return last_polled >= Clock::now() - ACTIVE_INPUT_TIMEOUT; +} + +JNIEXPORT void JNICALL +Java_org_dolphinemu_dolphinemu_features_input_model_ControllerInterface_notifySensorSuspendedState( + JNIEnv* env, jclass, jstring j_device_qualifier, jobjectArray j_axis_names, jboolean suspended) +{ + ciface::Core::DeviceQualifier device_qualifier; + device_qualifier.FromString(GetJString(env, j_device_qualifier)); + const std::shared_ptr<ciface::Core::Device> device = + g_controller_interface.FindDevice(device_qualifier); + if (!device) + return; + + const std::vector<std::string> axis_names = JStringArrayToVector(env, j_axis_names); + + for (ciface::Core::Device::Input* input : device->Inputs()) + { + const std::string input_name = input->GetName(); + if (std::find(axis_names.begin(), axis_names.end(), input_name) != axis_names.end()) + { + auto casted_input = static_cast<ciface::Android::AndroidSensorAxis*>(input); + casted_input->NotifyIsSuspended(static_cast<bool>(suspended)); + } + } +} + +JNIEXPORT void JNICALL +Java_org_dolphinemu_dolphinemu_features_input_model_ControllerInterface_refreshDevices(JNIEnv* env, + jclass) +{ + g_controller_interface.RefreshDevices(); +} + +JNIEXPORT jobjectArray JNICALL +Java_org_dolphinemu_dolphinemu_features_input_model_ControllerInterface_getAllDeviceStrings( + JNIEnv* env, jclass) +{ + return VectorToJStringArray(env, g_controller_interface.GetAllDeviceStrings()); +} + +JNIEXPORT jobject JNICALL +Java_org_dolphinemu_dolphinemu_features_input_model_ControllerInterface_getDevice( + JNIEnv* env, jclass, jstring j_device_string) +{ + ciface::Core::DeviceQualifier qualifier; + qualifier.FromString(GetJString(env, j_device_string)); + return CoreDeviceToJava(env, g_controller_interface.FindDevice(qualifier)); +} +} diff --git a/Source/Core/InputCommon/ControllerInterface/Android/Android.h b/Source/Core/InputCommon/ControllerInterface/Android/Android.h index 2cc3c5a22b..8b8478d7ac 100644 --- a/Source/Core/InputCommon/ControllerInterface/Android/Android.h +++ b/Source/Core/InputCommon/ControllerInterface/Android/Android.h @@ -1,11 +1,13 @@ -// Copyright 2008 Dolphin Emulator Project +// Copyright 2021 Dolphin Emulator Project // SPDX-License-Identifier: GPL-2.0-or-later #pragma once namespace ciface::Android { -void SetMotionSensorsEnabled(bool accelerometer_enabled, bool gyroscope_enabled); +void Init(); +void Shutdown(); void PopulateDevices(); + } // namespace ciface::Android diff --git a/Source/Core/InputCommon/ControllerInterface/ControllerInterface.cpp b/Source/Core/InputCommon/ControllerInterface/ControllerInterface.cpp index 6a6affd478..8f58525f0c 100644 --- a/Source/Core/InputCommon/ControllerInterface/ControllerInterface.cpp +++ b/Source/Core/InputCommon/ControllerInterface/ControllerInterface.cpp @@ -67,7 +67,7 @@ void ControllerInterface::Initialize(const WindowSystemInfo& wsi) m_input_backends.emplace_back(ciface::SDL::CreateInputBackend(this)); #endif #ifdef CIFACE_USE_ANDROID -// nothing needed + ciface::Android::Init(); #endif #ifdef CIFACE_USE_EVDEV m_input_backends.emplace_back(ciface::evdev::CreateInputBackend(this)); @@ -237,7 +237,7 @@ void ControllerInterface::Shutdown() ciface::Quartz::DeInit(); #endif #ifdef CIFACE_USE_ANDROID -// nothing needed + ciface::Android::Shutdown(); #endif // Empty the container of input backends to deconstruct and deinitialize them. diff --git a/Source/Core/InputCommon/ControllerInterface/CoreDevice.cpp b/Source/Core/InputCommon/ControllerInterface/CoreDevice.cpp index 4e46179fc6..222791f03f 100644 --- a/Source/Core/InputCommon/ControllerInterface/CoreDevice.cpp +++ b/Source/Core/InputCommon/ControllerInterface/CoreDevice.cpp @@ -242,6 +242,18 @@ std::shared_ptr<Device> DeviceContainer::FindDevice(const DeviceQualifier& devq) return nullptr; } +std::vector<std::shared_ptr<Device>> DeviceContainer::GetAllDevices() const +{ + std::lock_guard lk(m_devices_mutex); + + std::vector<std::shared_ptr<Device>> devices; + + for (const auto& d : m_devices) + devices.emplace_back(d); + + return devices; +} + std::vector<std::string> DeviceContainer::GetAllDeviceStrings() const { std::lock_guard lk(m_devices_mutex); diff --git a/Source/Core/InputCommon/ControllerInterface/CoreDevice.h b/Source/Core/InputCommon/ControllerInterface/CoreDevice.h index 2280ddac3b..a2176637ab 100644 --- a/Source/Core/InputCommon/ControllerInterface/CoreDevice.h +++ b/Source/Core/InputCommon/ControllerInterface/CoreDevice.h @@ -226,6 +226,7 @@ public: Device::Input* FindInput(std::string_view name, const Device* def_dev) const; Device::Output* FindOutput(std::string_view name, const Device* def_dev) const; + std::vector<std::shared_ptr<Device>> GetAllDevices() const; std::vector<std::string> GetAllDeviceStrings() const; bool HasDefaultDevice() const; std::string GetDefaultDeviceString() const; diff --git a/Source/Core/InputCommon/ControllerInterface/Touch/ButtonManager.cpp b/Source/Core/InputCommon/ControllerInterface/Touch/ButtonManager.cpp deleted file mode 100644 index 0111947608..0000000000 --- a/Source/Core/InputCommon/ControllerInterface/Touch/ButtonManager.cpp +++ /dev/null @@ -1,788 +0,0 @@ -// Copyright 2013 Dolphin Emulator Project -// SPDX-License-Identifier: GPL-2.0-or-later - -#include "InputCommon/ControllerInterface/Touch/ButtonManager.h" - -#include <array> -#include <sstream> -#include <string> -#include <unordered_map> -#include <vector> - -#include "Common/FileUtil.h" -#include "Common/IniFile.h" -#include "Common/StringUtil.h" -#include "Common/Thread.h" - -namespace ButtonManager -{ -namespace -{ -constexpr char TOUCHSCREEN_KEY[] = "Touchscreen"; -constexpr std::array<const char*, 155> CONFIG_STRINGS{{ - // GC - "InputA", - "InputB", - "InputStart", - "InputX", - "InputY", - "InputZ", - "DPadUp", - "DPadDown", - "DPadLeft", - "DPadRight", - "MainUp", - "MainDown", - "MainLeft", - "MainRight", - "CStickUp", - "CStickDown", - "CStickLeft", - "CStickRight", - "InputL", - "InputR", - // Wiimote - "WiimoteA", - "WiimoteB", - "WiimoteMinus", - "WiimotePlus", - "WiimoteHome", - "Wiimote1", - "Wiimote2", - "WiimoteUp", - "WiimoteDown", - "WiimoteLeft", - "WiimoteRight", - "IRUp", - "IRDown", - "IRLeft", - "IRRight", - "IRForward", - "IRBackward", - "IRHide", - "SwingUp", - "SwingDown", - "SwingLeft", - "SwingRight", - "SwingForward", - "SwingBackward", - "TiltForward", - "TiltBackward", - "TiltLeft", - "TiltRight", - "TiltModifier", - "ShakeX", - "ShakeY", - "ShakeZ", - // Nunchuk - "NunchukC", - "NunchukZ", - "NunchukUp", - "NunchukDown", - "NunchukLeft", - "NunchukRight", - "NunchukSwingUp", - "NunchukSwingDown", - "NunchukSwingLeft", - "NunchukSwingRight", - "NunchukSwingForward", - "NunchukSwingBackward", - "NunchukTiltForward", - "NunchukTiltBackward", - "NunchukTiltLeft", - "NunchukTiltRight", - "NunchukTiltModifier", - "NunchukShakeX", - "NunchukShakeY", - "NunchukShakeZ", - // Classic - "ClassicA", - "ClassicB", - "ClassicX", - "ClassicY", - "ClassicMinus", - "ClassicPlus", - "ClassicHome", - "ClassicZL", - "ClassicZR", - "ClassicUp", - "ClassicDown", - "ClassicLeft", - "ClassicRight", - "ClassicLeftStickUp", - "ClassicLeftStickDown", - "ClassicLeftStickLeft", - "ClassicLeftStickRight", - "ClassicRightStickUp", - "ClassicRightStickDown", - "ClassicRightStickLeft", - "ClassicRightStickRight", - "ClassicTriggerL", - "ClassicTriggerR", - // Guitar - "GuitarMinus", - "GuitarPlus", - "GuitarGreen", - "GuitarRed", - "GuitarYellow", - "GuitarBlue", - "GuitarOrange", - "GuitarStrumUp", - "GuitarStrumDown", - "GuitarUp", - "GuitarDown", - "GuitarLeft", - "GuitarRight", - "GuitarWhammy", - // Drums - "DrumsMinus", - "DrumsPlus", - "DrumsRed", - "DrumsYellow", - "DrumsBlue", - "DrumsGreen", - "DrumsOrange", - "DrumsBass", - "DrumsUp", - "DrumsDown", - "DrumsLeft", - "DrumsRight", - // Turntable - "TurntableGreenLeft", - "TurntableRedLeft", - "TurntableBlueLeft", - "TurntableGreenRight", - "TurntableRedRight", - "TurntableBlueRight", - "TurntableMinus", - "TurntablePlus", - "TurntableHome", - "TurntableEuphoria", - "TurntableLeftTLeft", - "TurntableLeftTRight", - "TurntableRightTLeft", - "TurntableRightTRight", - "TurntableUp", - "TurntableDown", - "TurntableLeft", - "TurntableRight", - "TurntableEffDial", - "TurntableCrossLeft", - "TurntableCrossRight", - // Wiimote IMU - "WiimoteAccelLeft", - "WiimoteAccelRight", - "WiimoteAccelForward", - "WiimoteAccelBackward", - "WiimoteAccelUp", - "WiimoteAccelDown", - "WiimoteGyroPitchUp", - "WiimoteGyroPitchDown", - "WiimoteGyroRollLeft", - "WiimoteGyroRollRight", - "WiimoteGyroYawLeft", - "WiimoteGyroYawRight", - // Rumble - "Rumble", -}}; - -constexpr std::array<ButtonType, 155> CONFIG_TYPES{{ - // GC - BUTTON_A, - BUTTON_B, - BUTTON_START, - BUTTON_X, - BUTTON_Y, - BUTTON_Z, - BUTTON_UP, - BUTTON_DOWN, - BUTTON_LEFT, - BUTTON_RIGHT, - STICK_MAIN_UP, - STICK_MAIN_DOWN, - STICK_MAIN_LEFT, - STICK_MAIN_RIGHT, - STICK_C_UP, - STICK_C_DOWN, - STICK_C_LEFT, - STICK_C_RIGHT, - TRIGGER_L, - TRIGGER_R, - // Wiimote - WIIMOTE_BUTTON_A, - WIIMOTE_BUTTON_B, - WIIMOTE_BUTTON_MINUS, - WIIMOTE_BUTTON_PLUS, - WIIMOTE_BUTTON_HOME, - WIIMOTE_BUTTON_1, - WIIMOTE_BUTTON_2, - WIIMOTE_UP, - WIIMOTE_DOWN, - WIIMOTE_LEFT, - WIIMOTE_RIGHT, - WIIMOTE_IR_UP, - WIIMOTE_IR_DOWN, - WIIMOTE_IR_LEFT, - WIIMOTE_IR_RIGHT, - WIIMOTE_IR_FORWARD, - WIIMOTE_IR_BACKWARD, - WIIMOTE_IR_HIDE, - WIIMOTE_SWING_UP, - WIIMOTE_SWING_DOWN, - WIIMOTE_SWING_LEFT, - WIIMOTE_SWING_RIGHT, - WIIMOTE_SWING_FORWARD, - WIIMOTE_SWING_BACKWARD, - WIIMOTE_TILT_FORWARD, - WIIMOTE_TILT_BACKWARD, - WIIMOTE_TILT_LEFT, - WIIMOTE_TILT_RIGHT, - WIIMOTE_TILT_MODIFIER, - WIIMOTE_SHAKE_X, - WIIMOTE_SHAKE_Y, - WIIMOTE_SHAKE_Z, - // Nunchuk - NUNCHUK_BUTTON_C, - NUNCHUK_BUTTON_Z, - NUNCHUK_STICK_UP, - NUNCHUK_STICK_DOWN, - NUNCHUK_STICK_LEFT, - NUNCHUK_STICK_RIGHT, - NUNCHUK_SWING_UP, - NUNCHUK_SWING_DOWN, - NUNCHUK_SWING_LEFT, - NUNCHUK_SWING_RIGHT, - NUNCHUK_SWING_FORWARD, - NUNCHUK_SWING_BACKWARD, - NUNCHUK_TILT_FORWARD, - NUNCHUK_TILT_BACKWARD, - NUNCHUK_TILT_LEFT, - NUNCHUK_TILT_RIGHT, - NUNCHUK_TILT_MODIFIER, - NUNCHUK_SHAKE_X, - NUNCHUK_SHAKE_Y, - NUNCHUK_SHAKE_Z, - // Classic - CLASSIC_BUTTON_A, - CLASSIC_BUTTON_B, - CLASSIC_BUTTON_X, - CLASSIC_BUTTON_Y, - CLASSIC_BUTTON_MINUS, - CLASSIC_BUTTON_PLUS, - CLASSIC_BUTTON_HOME, - CLASSIC_BUTTON_ZL, - CLASSIC_BUTTON_ZR, - CLASSIC_DPAD_UP, - CLASSIC_DPAD_DOWN, - CLASSIC_DPAD_LEFT, - CLASSIC_DPAD_RIGHT, - CLASSIC_STICK_LEFT_UP, - CLASSIC_STICK_LEFT_DOWN, - CLASSIC_STICK_LEFT_LEFT, - CLASSIC_STICK_LEFT_RIGHT, - CLASSIC_STICK_RIGHT_UP, - CLASSIC_STICK_RIGHT_DOWN, - CLASSIC_STICK_RIGHT_LEFT, - CLASSIC_STICK_RIGHT_RIGHT, - CLASSIC_TRIGGER_L, - CLASSIC_TRIGGER_R, - // Guitar - GUITAR_BUTTON_MINUS, - GUITAR_BUTTON_PLUS, - GUITAR_FRET_GREEN, - GUITAR_FRET_RED, - GUITAR_FRET_YELLOW, - GUITAR_FRET_BLUE, - GUITAR_FRET_ORANGE, - GUITAR_STRUM_UP, - GUITAR_STRUM_DOWN, - GUITAR_STICK_UP, - GUITAR_STICK_DOWN, - GUITAR_STICK_LEFT, - GUITAR_STICK_RIGHT, - GUITAR_WHAMMY_BAR, - // Drums - DRUMS_BUTTON_MINUS, - DRUMS_BUTTON_PLUS, - DRUMS_PAD_RED, - DRUMS_PAD_YELLOW, - DRUMS_PAD_BLUE, - DRUMS_PAD_GREEN, - DRUMS_PAD_ORANGE, - DRUMS_PAD_BASS, - DRUMS_STICK_UP, - DRUMS_STICK_DOWN, - DRUMS_STICK_LEFT, - DRUMS_STICK_RIGHT, - // Turntable - TURNTABLE_BUTTON_GREEN_LEFT, - TURNTABLE_BUTTON_RED_LEFT, - TURNTABLE_BUTTON_BLUE_LEFT, - TURNTABLE_BUTTON_GREEN_RIGHT, - TURNTABLE_BUTTON_RED_RIGHT, - TURNTABLE_BUTTON_BLUE_RIGHT, - TURNTABLE_BUTTON_MINUS, - TURNTABLE_BUTTON_PLUS, - TURNTABLE_BUTTON_HOME, - TURNTABLE_BUTTON_EUPHORIA, - TURNTABLE_TABLE_LEFT_LEFT, - TURNTABLE_TABLE_LEFT_RIGHT, - TURNTABLE_TABLE_RIGHT_LEFT, - TURNTABLE_TABLE_RIGHT_RIGHT, - TURNTABLE_STICK_UP, - TURNTABLE_STICK_DOWN, - TURNTABLE_STICK_LEFT, - TURNTABLE_STICK_RIGHT, - TURNTABLE_EFFECT_DIAL, - TURNTABLE_CROSSFADE_LEFT, - TURNTABLE_CROSSFADE_RIGHT, - // Wiimote IMU - WIIMOTE_ACCEL_LEFT, - WIIMOTE_ACCEL_RIGHT, - WIIMOTE_ACCEL_FORWARD, - WIIMOTE_ACCEL_BACKWARD, - WIIMOTE_ACCEL_UP, - WIIMOTE_ACCEL_DOWN, - WIIMOTE_GYRO_PITCH_UP, - WIIMOTE_GYRO_PITCH_DOWN, - WIIMOTE_GYRO_ROLL_LEFT, - WIIMOTE_GYRO_ROLL_RIGHT, - WIIMOTE_GYRO_YAW_LEFT, - WIIMOTE_GYRO_YAW_RIGHT, - // Rumble - RUMBLE, -}}; - -std::unordered_map<std::string, InputDevice*> m_controllers; - -void AddBind(const std::string& dev, sBind* bind) -{ - auto it = m_controllers.find(dev); - if (it != m_controllers.end()) - { - it->second->AddBind(bind); - return; - } - m_controllers[dev] = new InputDevice(dev); - m_controllers[dev]->AddBind(bind); -} -} // Anonymous namespace - -void Init(const std::string& game_id) -{ - // Initialize pad 0(gc 1) and pad 4(wii 1) as touch overlay controller - for (int a = 0; a < 5; a += 4) - { - // GC - AddBind(TOUCHSCREEN_KEY, new sBind(a, BUTTON_A, BIND_BUTTON, BUTTON_A, 1.0f)); - AddBind(TOUCHSCREEN_KEY, new sBind(a, BUTTON_B, BIND_BUTTON, BUTTON_B, 1.0f)); - AddBind(TOUCHSCREEN_KEY, new sBind(a, BUTTON_START, BIND_BUTTON, BUTTON_START, 1.0f)); - AddBind(TOUCHSCREEN_KEY, new sBind(a, BUTTON_X, BIND_BUTTON, BUTTON_X, 1.0f)); - AddBind(TOUCHSCREEN_KEY, new sBind(a, BUTTON_Y, BIND_BUTTON, BUTTON_Y, 1.0f)); - AddBind(TOUCHSCREEN_KEY, new sBind(a, BUTTON_Z, BIND_BUTTON, BUTTON_Z, 1.0f)); - AddBind(TOUCHSCREEN_KEY, new sBind(a, BUTTON_UP, BIND_BUTTON, BUTTON_UP, 1.0f)); - AddBind(TOUCHSCREEN_KEY, new sBind(a, BUTTON_DOWN, BIND_BUTTON, BUTTON_DOWN, 1.0f)); - AddBind(TOUCHSCREEN_KEY, new sBind(a, BUTTON_LEFT, BIND_BUTTON, BUTTON_LEFT, 1.0f)); - AddBind(TOUCHSCREEN_KEY, new sBind(a, BUTTON_RIGHT, BIND_BUTTON, BUTTON_RIGHT, 1.0f)); - - AddBind(TOUCHSCREEN_KEY, new sBind(a, STICK_MAIN_UP, BIND_AXIS, STICK_MAIN_UP, -1.0f)); - AddBind(TOUCHSCREEN_KEY, new sBind(a, STICK_MAIN_DOWN, BIND_AXIS, STICK_MAIN_DOWN, 1.0f)); - AddBind(TOUCHSCREEN_KEY, new sBind(a, STICK_MAIN_LEFT, BIND_AXIS, STICK_MAIN_LEFT, -1.0f)); - AddBind(TOUCHSCREEN_KEY, new sBind(a, STICK_MAIN_RIGHT, BIND_AXIS, STICK_MAIN_RIGHT, 1.0f)); - AddBind(TOUCHSCREEN_KEY, new sBind(a, STICK_C_UP, BIND_AXIS, STICK_C_UP, -1.0f)); - AddBind(TOUCHSCREEN_KEY, new sBind(a, STICK_C_DOWN, BIND_AXIS, STICK_C_DOWN, 1.0f)); - AddBind(TOUCHSCREEN_KEY, new sBind(a, STICK_C_LEFT, BIND_AXIS, STICK_C_LEFT, -1.0f)); - AddBind(TOUCHSCREEN_KEY, new sBind(a, STICK_C_RIGHT, BIND_AXIS, STICK_C_RIGHT, 1.0f)); - AddBind(TOUCHSCREEN_KEY, new sBind(a, TRIGGER_L, BIND_AXIS, TRIGGER_L, 1.0f)); - AddBind(TOUCHSCREEN_KEY, new sBind(a, TRIGGER_R, BIND_AXIS, TRIGGER_R, 1.0f)); - - // Wiimote - AddBind(TOUCHSCREEN_KEY, new sBind(a, WIIMOTE_BUTTON_A, BIND_BUTTON, WIIMOTE_BUTTON_A, 1.0f)); - AddBind(TOUCHSCREEN_KEY, new sBind(a, WIIMOTE_BUTTON_B, BIND_BUTTON, WIIMOTE_BUTTON_B, 1.0f)); - AddBind(TOUCHSCREEN_KEY, - new sBind(a, WIIMOTE_BUTTON_MINUS, BIND_BUTTON, WIIMOTE_BUTTON_MINUS, 1.0f)); - AddBind(TOUCHSCREEN_KEY, - new sBind(a, WIIMOTE_BUTTON_PLUS, BIND_BUTTON, WIIMOTE_BUTTON_PLUS, 1.0f)); - AddBind(TOUCHSCREEN_KEY, - new sBind(a, WIIMOTE_BUTTON_HOME, BIND_BUTTON, WIIMOTE_BUTTON_HOME, 1.0f)); - AddBind(TOUCHSCREEN_KEY, new sBind(a, WIIMOTE_BUTTON_1, BIND_BUTTON, WIIMOTE_BUTTON_1, 1.0f)); - AddBind(TOUCHSCREEN_KEY, new sBind(a, WIIMOTE_BUTTON_2, BIND_BUTTON, WIIMOTE_BUTTON_2, 1.0f)); - AddBind(TOUCHSCREEN_KEY, new sBind(a, WIIMOTE_UP, BIND_BUTTON, WIIMOTE_UP, 1.0f)); - AddBind(TOUCHSCREEN_KEY, new sBind(a, WIIMOTE_DOWN, BIND_BUTTON, WIIMOTE_DOWN, 1.0f)); - AddBind(TOUCHSCREEN_KEY, new sBind(a, WIIMOTE_LEFT, BIND_BUTTON, WIIMOTE_LEFT, 1.0f)); - AddBind(TOUCHSCREEN_KEY, new sBind(a, WIIMOTE_RIGHT, BIND_BUTTON, WIIMOTE_RIGHT, 1.0f)); - AddBind(TOUCHSCREEN_KEY, new sBind(a, WIIMOTE_IR_HIDE, BIND_BUTTON, WIIMOTE_IR_HIDE, 1.0f)); - AddBind(TOUCHSCREEN_KEY, - new sBind(a, WIIMOTE_TILT_MODIFIER, BIND_BUTTON, WIIMOTE_TILT_MODIFIER, 1.0f)); - AddBind(TOUCHSCREEN_KEY, new sBind(a, WIIMOTE_SHAKE_X, BIND_BUTTON, WIIMOTE_SHAKE_X, 1.0f)); - AddBind(TOUCHSCREEN_KEY, new sBind(a, WIIMOTE_SHAKE_Y, BIND_BUTTON, WIIMOTE_SHAKE_Y, 1.0f)); - AddBind(TOUCHSCREEN_KEY, new sBind(a, WIIMOTE_SHAKE_Z, BIND_BUTTON, WIIMOTE_SHAKE_Z, 1.0f)); - - AddBind(TOUCHSCREEN_KEY, new sBind(a, WIIMOTE_IR_UP, BIND_AXIS, WIIMOTE_IR_UP, -1.0f)); - AddBind(TOUCHSCREEN_KEY, new sBind(a, WIIMOTE_IR_DOWN, BIND_AXIS, WIIMOTE_IR_DOWN, 1.0f)); - AddBind(TOUCHSCREEN_KEY, new sBind(a, WIIMOTE_IR_LEFT, BIND_AXIS, WIIMOTE_IR_LEFT, -1.0f)); - AddBind(TOUCHSCREEN_KEY, new sBind(a, WIIMOTE_IR_RIGHT, BIND_AXIS, WIIMOTE_IR_RIGHT, 1.0f)); - AddBind(TOUCHSCREEN_KEY, - new sBind(a, WIIMOTE_IR_FORWARD, BIND_AXIS, WIIMOTE_IR_FORWARD, -1.0f)); - AddBind(TOUCHSCREEN_KEY, - new sBind(a, WIIMOTE_IR_BACKWARD, BIND_AXIS, WIIMOTE_IR_BACKWARD, 1.0f)); - AddBind(TOUCHSCREEN_KEY, new sBind(a, WIIMOTE_SWING_UP, BIND_AXIS, WIIMOTE_SWING_UP, -1.0f)); - AddBind(TOUCHSCREEN_KEY, new sBind(a, WIIMOTE_SWING_DOWN, BIND_AXIS, WIIMOTE_SWING_DOWN, 1.0f)); - AddBind(TOUCHSCREEN_KEY, - new sBind(a, WIIMOTE_SWING_LEFT, BIND_AXIS, WIIMOTE_SWING_LEFT, -1.0f)); - AddBind(TOUCHSCREEN_KEY, - new sBind(a, WIIMOTE_SWING_RIGHT, BIND_AXIS, WIIMOTE_SWING_RIGHT, 1.0f)); - AddBind(TOUCHSCREEN_KEY, - new sBind(a, WIIMOTE_SWING_FORWARD, BIND_AXIS, WIIMOTE_SWING_FORWARD, -1.0f)); - AddBind(TOUCHSCREEN_KEY, - new sBind(a, WIIMOTE_SWING_BACKWARD, BIND_AXIS, WIIMOTE_SWING_BACKWARD, 1.0f)); - AddBind(TOUCHSCREEN_KEY, - new sBind(a, WIIMOTE_TILT_FORWARD, BIND_AXIS, WIIMOTE_TILT_FORWARD, -1.0f)); - AddBind(TOUCHSCREEN_KEY, - new sBind(a, WIIMOTE_TILT_BACKWARD, BIND_AXIS, WIIMOTE_TILT_BACKWARD, 1.0f)); - AddBind(TOUCHSCREEN_KEY, new sBind(a, WIIMOTE_TILT_LEFT, BIND_AXIS, WIIMOTE_TILT_LEFT, -1.0f)); - AddBind(TOUCHSCREEN_KEY, new sBind(a, WIIMOTE_TILT_RIGHT, BIND_AXIS, WIIMOTE_TILT_RIGHT, 1.0f)); - - // Wii: Nunchuk - AddBind(TOUCHSCREEN_KEY, new sBind(a, NUNCHUK_BUTTON_C, BIND_BUTTON, NUNCHUK_BUTTON_C, 1.0f)); - AddBind(TOUCHSCREEN_KEY, new sBind(a, NUNCHUK_BUTTON_Z, BIND_BUTTON, NUNCHUK_BUTTON_Z, 1.0f)); - AddBind(TOUCHSCREEN_KEY, - new sBind(a, NUNCHUK_TILT_MODIFIER, BIND_BUTTON, NUNCHUK_TILT_MODIFIER, 1.0f)); - AddBind(TOUCHSCREEN_KEY, new sBind(a, NUNCHUK_SHAKE_X, BIND_BUTTON, NUNCHUK_SHAKE_X, 1.0f)); - AddBind(TOUCHSCREEN_KEY, new sBind(a, NUNCHUK_SHAKE_Y, BIND_BUTTON, NUNCHUK_SHAKE_Y, 1.0f)); - AddBind(TOUCHSCREEN_KEY, new sBind(a, NUNCHUK_SHAKE_Z, BIND_BUTTON, NUNCHUK_SHAKE_Z, 1.0f)); - - AddBind(TOUCHSCREEN_KEY, new sBind(a, NUNCHUK_SWING_UP, BIND_AXIS, NUNCHUK_SWING_UP, -1.0f)); - AddBind(TOUCHSCREEN_KEY, new sBind(a, NUNCHUK_SWING_DOWN, BIND_AXIS, NUNCHUK_SWING_DOWN, 1.0f)); - AddBind(TOUCHSCREEN_KEY, - new sBind(a, NUNCHUK_SWING_LEFT, BIND_AXIS, NUNCHUK_SWING_LEFT, -1.0f)); - AddBind(TOUCHSCREEN_KEY, - new sBind(a, NUNCHUK_SWING_RIGHT, BIND_AXIS, NUNCHUK_SWING_RIGHT, 1.0f)); - AddBind(TOUCHSCREEN_KEY, - new sBind(a, NUNCHUK_SWING_FORWARD, BIND_AXIS, NUNCHUK_SWING_FORWARD, -1.0f)); - AddBind(TOUCHSCREEN_KEY, - new sBind(a, NUNCHUK_SWING_BACKWARD, BIND_BUTTON, NUNCHUK_SWING_BACKWARD, 1.0f)); - AddBind(TOUCHSCREEN_KEY, - new sBind(a, NUNCHUK_TILT_FORWARD, BIND_AXIS, NUNCHUK_TILT_FORWARD, -1.0f)); - AddBind(TOUCHSCREEN_KEY, - new sBind(a, NUNCHUK_TILT_BACKWARD, BIND_AXIS, NUNCHUK_TILT_BACKWARD, 1.0f)); - AddBind(TOUCHSCREEN_KEY, new sBind(a, NUNCHUK_TILT_LEFT, BIND_AXIS, NUNCHUK_TILT_LEFT, -1.0f)); - AddBind(TOUCHSCREEN_KEY, new sBind(a, NUNCHUK_TILT_RIGHT, BIND_AXIS, NUNCHUK_TILT_RIGHT, 1.0f)); - AddBind(TOUCHSCREEN_KEY, new sBind(a, NUNCHUK_STICK_UP, BIND_AXIS, NUNCHUK_STICK_UP, -1.0f)); - AddBind(TOUCHSCREEN_KEY, new sBind(a, NUNCHUK_STICK_DOWN, BIND_AXIS, NUNCHUK_STICK_DOWN, 1.0f)); - AddBind(TOUCHSCREEN_KEY, - new sBind(a, NUNCHUK_STICK_LEFT, BIND_AXIS, NUNCHUK_STICK_LEFT, -1.0f)); - AddBind(TOUCHSCREEN_KEY, - new sBind(a, NUNCHUK_STICK_RIGHT, BIND_AXIS, NUNCHUK_STICK_RIGHT, 1.0f)); - - // Wii: Classic - AddBind(TOUCHSCREEN_KEY, new sBind(a, CLASSIC_BUTTON_A, BIND_BUTTON, CLASSIC_BUTTON_A, 1.0f)); - AddBind(TOUCHSCREEN_KEY, new sBind(a, CLASSIC_BUTTON_B, BIND_BUTTON, CLASSIC_BUTTON_B, 1.0f)); - AddBind(TOUCHSCREEN_KEY, new sBind(a, CLASSIC_BUTTON_X, BIND_BUTTON, CLASSIC_BUTTON_X, 1.0f)); - AddBind(TOUCHSCREEN_KEY, new sBind(a, CLASSIC_BUTTON_Y, BIND_BUTTON, CLASSIC_BUTTON_Y, 1.0f)); - AddBind(TOUCHSCREEN_KEY, - new sBind(a, CLASSIC_BUTTON_MINUS, BIND_BUTTON, CLASSIC_BUTTON_MINUS, 1.0f)); - AddBind(TOUCHSCREEN_KEY, - new sBind(a, CLASSIC_BUTTON_PLUS, BIND_BUTTON, CLASSIC_BUTTON_PLUS, 1.0f)); - AddBind(TOUCHSCREEN_KEY, - new sBind(a, CLASSIC_BUTTON_HOME, BIND_BUTTON, CLASSIC_BUTTON_HOME, 1.0f)); - AddBind(TOUCHSCREEN_KEY, new sBind(a, CLASSIC_BUTTON_ZL, BIND_BUTTON, CLASSIC_BUTTON_ZL, 1.0f)); - AddBind(TOUCHSCREEN_KEY, new sBind(a, CLASSIC_BUTTON_ZR, BIND_BUTTON, CLASSIC_BUTTON_ZR, 1.0f)); - AddBind(TOUCHSCREEN_KEY, new sBind(a, CLASSIC_DPAD_UP, BIND_BUTTON, CLASSIC_DPAD_UP, 1.0f)); - AddBind(TOUCHSCREEN_KEY, new sBind(a, CLASSIC_DPAD_DOWN, BIND_BUTTON, CLASSIC_DPAD_DOWN, 1.0f)); - AddBind(TOUCHSCREEN_KEY, new sBind(a, CLASSIC_DPAD_LEFT, BIND_BUTTON, CLASSIC_DPAD_LEFT, 1.0f)); - AddBind(TOUCHSCREEN_KEY, - new sBind(a, CLASSIC_DPAD_RIGHT, BIND_BUTTON, CLASSIC_DPAD_RIGHT, 1.0f)); - - AddBind(TOUCHSCREEN_KEY, - new sBind(a, CLASSIC_STICK_LEFT_UP, BIND_AXIS, CLASSIC_STICK_LEFT_UP, -1.0f)); - AddBind(TOUCHSCREEN_KEY, - new sBind(a, CLASSIC_STICK_LEFT_DOWN, BIND_AXIS, CLASSIC_STICK_LEFT_DOWN, 1.0f)); - AddBind(TOUCHSCREEN_KEY, - new sBind(a, CLASSIC_STICK_LEFT_LEFT, BIND_AXIS, CLASSIC_STICK_LEFT_LEFT, -1.0f)); - AddBind(TOUCHSCREEN_KEY, - new sBind(a, CLASSIC_STICK_LEFT_RIGHT, BIND_AXIS, CLASSIC_STICK_LEFT_RIGHT, 1.0f)); - AddBind(TOUCHSCREEN_KEY, - new sBind(a, CLASSIC_STICK_RIGHT_UP, BIND_AXIS, CLASSIC_STICK_RIGHT_UP, -1.0f)); - AddBind(TOUCHSCREEN_KEY, - new sBind(a, CLASSIC_STICK_RIGHT_DOWN, BIND_AXIS, CLASSIC_STICK_RIGHT_DOWN, 1.0f)); - AddBind(TOUCHSCREEN_KEY, - new sBind(a, CLASSIC_STICK_RIGHT_LEFT, BIND_AXIS, CLASSIC_STICK_RIGHT_LEFT, -1.0f)); - AddBind(TOUCHSCREEN_KEY, - new sBind(a, CLASSIC_STICK_RIGHT_RIGHT, BIND_AXIS, CLASSIC_STICK_RIGHT_RIGHT, 1.0f)); - AddBind(TOUCHSCREEN_KEY, new sBind(a, CLASSIC_TRIGGER_L, BIND_AXIS, CLASSIC_TRIGGER_L, 1.0f)); - AddBind(TOUCHSCREEN_KEY, new sBind(a, CLASSIC_TRIGGER_R, BIND_AXIS, CLASSIC_TRIGGER_R, 1.0f)); - - // Wii: Guitar - AddBind(TOUCHSCREEN_KEY, - new sBind(a, GUITAR_BUTTON_MINUS, BIND_BUTTON, GUITAR_BUTTON_MINUS, 1.0f)); - AddBind(TOUCHSCREEN_KEY, - new sBind(a, GUITAR_BUTTON_PLUS, BIND_BUTTON, GUITAR_BUTTON_PLUS, 1.0f)); - AddBind(TOUCHSCREEN_KEY, new sBind(a, GUITAR_FRET_GREEN, BIND_BUTTON, GUITAR_FRET_GREEN, 1.0f)); - AddBind(TOUCHSCREEN_KEY, new sBind(a, GUITAR_FRET_RED, BIND_BUTTON, GUITAR_FRET_RED, 1.0f)); - AddBind(TOUCHSCREEN_KEY, - new sBind(a, GUITAR_FRET_YELLOW, BIND_BUTTON, GUITAR_FRET_YELLOW, 1.0f)); - AddBind(TOUCHSCREEN_KEY, new sBind(a, GUITAR_FRET_BLUE, BIND_BUTTON, GUITAR_FRET_BLUE, 1.0f)); - AddBind(TOUCHSCREEN_KEY, - new sBind(a, GUITAR_FRET_ORANGE, BIND_BUTTON, GUITAR_FRET_ORANGE, 1.0f)); - AddBind(TOUCHSCREEN_KEY, new sBind(a, GUITAR_STRUM_UP, BIND_BUTTON, GUITAR_STRUM_UP, 1.0f)); - AddBind(TOUCHSCREEN_KEY, new sBind(a, GUITAR_STRUM_DOWN, BIND_BUTTON, GUITAR_STRUM_DOWN, 1.0f)); - - AddBind(TOUCHSCREEN_KEY, new sBind(a, GUITAR_STICK_UP, BIND_AXIS, GUITAR_STICK_UP, -1.0f)); - AddBind(TOUCHSCREEN_KEY, new sBind(a, GUITAR_STICK_DOWN, BIND_AXIS, GUITAR_STICK_DOWN, 1.0f)); - AddBind(TOUCHSCREEN_KEY, new sBind(a, GUITAR_STICK_LEFT, BIND_AXIS, GUITAR_STICK_LEFT, -1.0f)); - AddBind(TOUCHSCREEN_KEY, new sBind(a, GUITAR_STICK_RIGHT, BIND_AXIS, GUITAR_STICK_RIGHT, 1.0f)); - AddBind(TOUCHSCREEN_KEY, new sBind(a, GUITAR_WHAMMY_BAR, BIND_AXIS, GUITAR_WHAMMY_BAR, 1.0f)); - - // Wii: Drums - AddBind(TOUCHSCREEN_KEY, - new sBind(a, DRUMS_BUTTON_MINUS, BIND_BUTTON, DRUMS_BUTTON_MINUS, 1.0f)); - AddBind(TOUCHSCREEN_KEY, new sBind(a, DRUMS_BUTTON_PLUS, BIND_BUTTON, DRUMS_BUTTON_PLUS, 1.0f)); - AddBind(TOUCHSCREEN_KEY, new sBind(a, DRUMS_PAD_RED, BIND_BUTTON, DRUMS_PAD_RED, 1.0f)); - AddBind(TOUCHSCREEN_KEY, new sBind(a, DRUMS_PAD_YELLOW, BIND_BUTTON, DRUMS_PAD_YELLOW, 1.0f)); - AddBind(TOUCHSCREEN_KEY, new sBind(a, DRUMS_PAD_BLUE, BIND_BUTTON, DRUMS_PAD_BLUE, 1.0f)); - AddBind(TOUCHSCREEN_KEY, new sBind(a, DRUMS_PAD_GREEN, BIND_BUTTON, DRUMS_PAD_GREEN, 1.0f)); - AddBind(TOUCHSCREEN_KEY, new sBind(a, DRUMS_PAD_ORANGE, BIND_BUTTON, DRUMS_PAD_ORANGE, 1.0f)); - AddBind(TOUCHSCREEN_KEY, new sBind(a, DRUMS_PAD_BASS, BIND_BUTTON, DRUMS_PAD_BASS, 1.0f)); - - AddBind(TOUCHSCREEN_KEY, new sBind(a, DRUMS_STICK_UP, BIND_AXIS, DRUMS_STICK_UP, -1.0f)); - AddBind(TOUCHSCREEN_KEY, new sBind(a, DRUMS_STICK_DOWN, BIND_AXIS, DRUMS_STICK_DOWN, 1.0f)); - AddBind(TOUCHSCREEN_KEY, new sBind(a, DRUMS_STICK_LEFT, BIND_AXIS, DRUMS_STICK_LEFT, -1.0f)); - AddBind(TOUCHSCREEN_KEY, new sBind(a, DRUMS_STICK_RIGHT, BIND_AXIS, DRUMS_STICK_RIGHT, 1.0f)); - - // Wii: Turntable - AddBind(TOUCHSCREEN_KEY, new sBind(a, TURNTABLE_BUTTON_GREEN_LEFT, BIND_BUTTON, - TURNTABLE_BUTTON_GREEN_LEFT, 1.0f)); - AddBind(TOUCHSCREEN_KEY, - new sBind(a, TURNTABLE_BUTTON_RED_LEFT, BIND_BUTTON, TURNTABLE_BUTTON_RED_LEFT, 1.0f)); - AddBind(TOUCHSCREEN_KEY, new sBind(a, TURNTABLE_BUTTON_BLUE_LEFT, BIND_BUTTON, - TURNTABLE_BUTTON_BLUE_LEFT, 1.0f)); - AddBind(TOUCHSCREEN_KEY, new sBind(a, TURNTABLE_BUTTON_GREEN_RIGHT, BIND_BUTTON, - TURNTABLE_BUTTON_GREEN_RIGHT, 1.0f)); - AddBind(TOUCHSCREEN_KEY, new sBind(a, TURNTABLE_BUTTON_RED_RIGHT, BIND_BUTTON, - TURNTABLE_BUTTON_RED_RIGHT, 1.0f)); - AddBind(TOUCHSCREEN_KEY, new sBind(a, TURNTABLE_BUTTON_BLUE_RIGHT, BIND_BUTTON, - TURNTABLE_BUTTON_BLUE_RIGHT, 1.0f)); - AddBind(TOUCHSCREEN_KEY, - new sBind(a, TURNTABLE_BUTTON_MINUS, BIND_BUTTON, TURNTABLE_BUTTON_MINUS, 1.0f)); - AddBind(TOUCHSCREEN_KEY, - new sBind(a, TURNTABLE_BUTTON_PLUS, BIND_BUTTON, TURNTABLE_BUTTON_PLUS, 1.0f)); - AddBind(TOUCHSCREEN_KEY, - new sBind(a, TURNTABLE_BUTTON_HOME, BIND_BUTTON, TURNTABLE_BUTTON_HOME, 1.0f)); - AddBind(TOUCHSCREEN_KEY, - new sBind(a, TURNTABLE_BUTTON_EUPHORIA, BIND_BUTTON, TURNTABLE_BUTTON_EUPHORIA, 1.0f)); - - AddBind(TOUCHSCREEN_KEY, - new sBind(a, TURNTABLE_TABLE_LEFT_LEFT, BIND_AXIS, TURNTABLE_TABLE_LEFT_LEFT, -1.0f)); - AddBind(TOUCHSCREEN_KEY, - new sBind(a, TURNTABLE_TABLE_LEFT_RIGHT, BIND_AXIS, TURNTABLE_TABLE_LEFT_RIGHT, 1.0f)); - AddBind(TOUCHSCREEN_KEY, - new sBind(a, TURNTABLE_TABLE_RIGHT_LEFT, BIND_AXIS, TURNTABLE_TABLE_RIGHT_LEFT, -1.0f)); - AddBind(TOUCHSCREEN_KEY, new sBind(a, TURNTABLE_TABLE_RIGHT_RIGHT, BIND_AXIS, - TURNTABLE_TABLE_RIGHT_RIGHT, 1.0f)); - AddBind(TOUCHSCREEN_KEY, - new sBind(a, TURNTABLE_STICK_UP, BIND_AXIS, TURNTABLE_STICK_UP, -1.0f)); - AddBind(TOUCHSCREEN_KEY, - new sBind(a, TURNTABLE_STICK_DOWN, BIND_AXIS, TURNTABLE_STICK_DOWN, 1.0f)); - AddBind(TOUCHSCREEN_KEY, - new sBind(a, TURNTABLE_STICK_LEFT, BIND_AXIS, TURNTABLE_STICK_LEFT, -1.0f)); - AddBind(TOUCHSCREEN_KEY, - new sBind(a, TURNTABLE_STICK_RIGHT, BIND_AXIS, TURNTABLE_STICK_RIGHT, 1.0f)); - AddBind(TOUCHSCREEN_KEY, - new sBind(a, TURNTABLE_EFFECT_DIAL, BIND_AXIS, TURNTABLE_EFFECT_DIAL, 1.0f)); - AddBind(TOUCHSCREEN_KEY, - new sBind(a, TURNTABLE_CROSSFADE_LEFT, BIND_AXIS, TURNTABLE_CROSSFADE_LEFT, -1.0f)); - AddBind(TOUCHSCREEN_KEY, - new sBind(a, TURNTABLE_CROSSFADE_RIGHT, BIND_AXIS, TURNTABLE_CROSSFADE_RIGHT, 1.0f)); - - // Wiimote IMU - AddBind(TOUCHSCREEN_KEY, new sBind(a, WIIMOTE_ACCEL_LEFT, BIND_AXIS, WIIMOTE_ACCEL_LEFT, 1.0f)); - AddBind(TOUCHSCREEN_KEY, - new sBind(a, WIIMOTE_ACCEL_RIGHT, BIND_AXIS, WIIMOTE_ACCEL_RIGHT, -1.0f)); - AddBind(TOUCHSCREEN_KEY, - new sBind(a, WIIMOTE_ACCEL_FORWARD, BIND_AXIS, WIIMOTE_ACCEL_FORWARD, -1.0f)); - AddBind(TOUCHSCREEN_KEY, - new sBind(a, WIIMOTE_ACCEL_BACKWARD, BIND_AXIS, WIIMOTE_ACCEL_BACKWARD, 1.0f)); - AddBind(TOUCHSCREEN_KEY, new sBind(a, WIIMOTE_ACCEL_UP, BIND_AXIS, WIIMOTE_ACCEL_UP, 1.0f)); - AddBind(TOUCHSCREEN_KEY, - new sBind(a, WIIMOTE_ACCEL_DOWN, BIND_AXIS, WIIMOTE_ACCEL_DOWN, -1.0f)); - AddBind(TOUCHSCREEN_KEY, - new sBind(a, WIIMOTE_GYRO_PITCH_UP, BIND_AXIS, WIIMOTE_GYRO_PITCH_UP, -1.0f)); - AddBind(TOUCHSCREEN_KEY, - new sBind(a, WIIMOTE_GYRO_PITCH_DOWN, BIND_AXIS, WIIMOTE_GYRO_PITCH_DOWN, 1.0f)); - AddBind(TOUCHSCREEN_KEY, - new sBind(a, WIIMOTE_GYRO_ROLL_LEFT, BIND_AXIS, WIIMOTE_GYRO_ROLL_LEFT, 1.0f)); - AddBind(TOUCHSCREEN_KEY, - new sBind(a, WIIMOTE_GYRO_ROLL_RIGHT, BIND_AXIS, WIIMOTE_GYRO_ROLL_RIGHT, -1.0f)); - AddBind(TOUCHSCREEN_KEY, - new sBind(a, WIIMOTE_GYRO_YAW_LEFT, BIND_AXIS, WIIMOTE_GYRO_YAW_LEFT, 1.0f)); - AddBind(TOUCHSCREEN_KEY, - new sBind(a, WIIMOTE_GYRO_YAW_RIGHT, BIND_AXIS, WIIMOTE_GYRO_YAW_RIGHT, -1.0f)); - } - // Init our controller bindings - IniFile ini; - ini.Load(File::GetUserPath(D_CONFIG_IDX) + std::string("Dolphin.ini"), true); - ini.Load(File::GetUserPath(D_GAMESETTINGS_IDX) + std::string(game_id + ".ini"), true); - for (u32 a = 0; a < CONFIG_STRINGS.size(); ++a) - { - for (int pad_id = 0; pad_id < 8; ++pad_id) - { - std::ostringstream config; - config << CONFIG_STRINGS[a] << "_" << pad_id; - BindType type; - int bindnum; - char dev[128]{}; - bool hasbind = false; - char modifier = '+'; - std::string value; - ini.GetOrCreateSection("Android")->Get(config.str(), &value, "None"); - if (value == "None") - continue; - if (std::string::npos != value.find("Axis")) - { - hasbind = true; - type = BIND_AXIS; - if (value.starts_with("Device ''")) - sscanf(value.c_str(), "Device ''-Axis %d%c", &bindnum, &modifier); - else - sscanf(value.c_str(), "Device '%127[^\']'-Axis %d%c", dev, &bindnum, &modifier); - } - else if (std::string::npos != value.find("Button")) - { - hasbind = true; - type = BIND_BUTTON; - if (value.starts_with("Device ''")) - sscanf(value.c_str(), "Device ''-Button %d", &bindnum); - else - sscanf(value.c_str(), "Device '%127[^\']'-Button %d", dev, &bindnum); - } - if (hasbind) - AddBind(std::string(dev), - new sBind(pad_id, CONFIG_TYPES[a], type, bindnum, modifier == '-' ? -1.0f : 1.0f)); - } - } -} - -bool GetButtonPressed(int pad_id, ButtonType button) -{ - bool pressed = m_controllers[TOUCHSCREEN_KEY]->ButtonValue(pad_id, button); - - for (const auto& ctrl : m_controllers) - pressed |= ctrl.second->ButtonValue(pad_id, button); - - return pressed; -} - -float GetAxisValue(int pad_id, ButtonType axis) -{ - float value = m_controllers[TOUCHSCREEN_KEY]->AxisValue(pad_id, axis); - if (value == 0.0f) - { - for (const auto& ctrl : m_controllers) - { - value = ctrl.second->AxisValue(pad_id, axis); - if (value != 0.0f) - return value; - } - } - return value; -} - -bool GamepadEvent(const std::string& dev, int button, int action) -{ - auto it = m_controllers.find(dev); - if (it != m_controllers.end()) - return it->second->PressEvent(button, action); - return false; -} - -void GamepadAxisEvent(const std::string& dev, int axis, float value) -{ - auto it = m_controllers.find(dev); - if (it != m_controllers.end()) - it->second->AxisEvent(axis, value); -} - -void Shutdown() -{ - for (const auto& controller : m_controllers) - delete controller.second; - m_controllers.clear(); -} - -// InputDevice -bool InputDevice::PressEvent(int button, int action) -{ - bool handled = false; - for (const auto& binding : m_input_binds) - { - if (binding.second->m_bind == button) - { - if (binding.second->m_bind_type == BIND_BUTTON) - m_buttons[binding.second->m_button_type] = action == BUTTON_PRESSED ? true : false; - else - m_axes[binding.second->m_button_type] = action == BUTTON_PRESSED ? 1.0f : 0.0f; - handled = true; - } - } - return handled; -} - -void InputDevice::AxisEvent(int axis, float value) -{ - for (const auto& binding : m_input_binds) - { - if (binding.second->m_bind == axis) - { - if (binding.second->m_bind_type == BIND_AXIS) - m_axes[binding.second->m_button_type] = value; - else - m_buttons[binding.second->m_button_type] = value > 0.5f ? true : false; - } - } -} - -bool InputDevice::ButtonValue(int pad_id, ButtonType button) const -{ - const auto binding = m_input_binds.find(std::make_pair(pad_id, button)); - if (binding == m_input_binds.end()) - return false; - - if (binding->second->m_bind_type == BIND_BUTTON) - { - const auto button = m_buttons.find(binding->second->m_button_type); - if (button == m_buttons.end()) - return false; - return button->second; - } - else - { - const auto axis = m_axes.find(binding->second->m_button_type); - if (axis == m_axes.end()) - return false; - return (axis->second * binding->second->m_neg) > 0.5f; - } -} - -float InputDevice::AxisValue(int pad_id, ButtonType axis) const -{ - const auto binding = m_input_binds.find(std::make_pair(pad_id, axis)); - if (binding == m_input_binds.end()) - return 0.0f; - - if (binding->second->m_bind_type == BIND_AXIS) - { - const auto axis = m_axes.find(binding->second->m_button_type); - if (axis == m_axes.end()) - return 0.0f; - return axis->second * binding->second->m_neg; - } - else - { - const auto button = m_buttons.find(binding->second->m_button_type); - if (button == m_buttons.end()) - return 0.0f; - return button->second == BUTTON_PRESSED ? 1.0f : 0.0f; - } -} -} // namespace ButtonManager diff --git a/Source/Core/InputCommon/ControllerInterface/Touch/ButtonManager.h b/Source/Core/InputCommon/ControllerInterface/Touch/ButtonManager.h deleted file mode 100644 index 08c4349c84..0000000000 --- a/Source/Core/InputCommon/ControllerInterface/Touch/ButtonManager.h +++ /dev/null @@ -1,279 +0,0 @@ -// Copyright 2013 Dolphin Emulator Project -// SPDX-License-Identifier: GPL-2.0-or-later - -#pragma once - -#include <map> -#include <string> - -namespace ButtonManager -{ -enum ButtonType -{ - // GC - BUTTON_A = 0, - BUTTON_B = 1, - BUTTON_START = 2, - BUTTON_X = 3, - BUTTON_Y = 4, - BUTTON_Z = 5, - BUTTON_UP = 6, - BUTTON_DOWN = 7, - BUTTON_LEFT = 8, - BUTTON_RIGHT = 9, - STICK_MAIN = 10, // Used on Java Side - STICK_MAIN_UP = 11, - STICK_MAIN_DOWN = 12, - STICK_MAIN_LEFT = 13, - STICK_MAIN_RIGHT = 14, - STICK_C = 15, // Used on Java Side - STICK_C_UP = 16, - STICK_C_DOWN = 17, - STICK_C_LEFT = 18, - STICK_C_RIGHT = 19, - TRIGGER_L = 20, - TRIGGER_R = 21, - // Wiimote - WIIMOTE_BUTTON_A = 100, - WIIMOTE_BUTTON_B = 101, - WIIMOTE_BUTTON_MINUS = 102, - WIIMOTE_BUTTON_PLUS = 103, - WIIMOTE_BUTTON_HOME = 104, - WIIMOTE_BUTTON_1 = 105, - WIIMOTE_BUTTON_2 = 106, - WIIMOTE_UP = 107, - WIIMOTE_DOWN = 108, - WIIMOTE_LEFT = 109, - WIIMOTE_RIGHT = 110, - WIIMOTE_IR = 111, // To Be Used on Java Side - WIIMOTE_IR_UP = 112, - WIIMOTE_IR_DOWN = 113, - WIIMOTE_IR_LEFT = 114, - WIIMOTE_IR_RIGHT = 115, - WIIMOTE_IR_FORWARD = 116, - WIIMOTE_IR_BACKWARD = 117, - WIIMOTE_IR_HIDE = 118, - WIIMOTE_SWING = 119, // To Be Used on Java Side - WIIMOTE_SWING_UP = 120, - WIIMOTE_SWING_DOWN = 121, - WIIMOTE_SWING_LEFT = 122, - WIIMOTE_SWING_RIGHT = 123, - WIIMOTE_SWING_FORWARD = 124, - WIIMOTE_SWING_BACKWARD = 125, - WIIMOTE_TILT = 126, // To Be Used on Java Side - WIIMOTE_TILT_FORWARD = 127, - WIIMOTE_TILT_BACKWARD = 128, - WIIMOTE_TILT_LEFT = 129, - WIIMOTE_TILT_RIGHT = 130, - WIIMOTE_TILT_MODIFIER = 131, - WIIMOTE_SHAKE_X = 132, - WIIMOTE_SHAKE_Y = 133, - WIIMOTE_SHAKE_Z = 134, - // Nunchuk - NUNCHUK_BUTTON_C = 200, - NUNCHUK_BUTTON_Z = 201, - NUNCHUK_STICK = 202, // To Be Used on Java Side - NUNCHUK_STICK_UP = 203, - NUNCHUK_STICK_DOWN = 204, - NUNCHUK_STICK_LEFT = 205, - NUNCHUK_STICK_RIGHT = 206, - NUNCHUK_SWING = 207, // To Be Used on Java Side - NUNCHUK_SWING_UP = 208, - NUNCHUK_SWING_DOWN = 209, - NUNCHUK_SWING_LEFT = 210, - NUNCHUK_SWING_RIGHT = 211, - NUNCHUK_SWING_FORWARD = 212, - NUNCHUK_SWING_BACKWARD = 213, - NUNCHUK_TILT = 214, // To Be Used on Java Side - NUNCHUK_TILT_FORWARD = 215, - NUNCHUK_TILT_BACKWARD = 216, - NUNCHUK_TILT_LEFT = 217, - NUNCHUK_TILT_RIGHT = 218, - NUNCHUK_TILT_MODIFIER = 219, - NUNCHUK_SHAKE_X = 220, - NUNCHUK_SHAKE_Y = 221, - NUNCHUK_SHAKE_Z = 222, - // Classic - CLASSIC_BUTTON_A = 300, - CLASSIC_BUTTON_B = 301, - CLASSIC_BUTTON_X = 302, - CLASSIC_BUTTON_Y = 303, - CLASSIC_BUTTON_MINUS = 304, - CLASSIC_BUTTON_PLUS = 305, - CLASSIC_BUTTON_HOME = 306, - CLASSIC_BUTTON_ZL = 307, - CLASSIC_BUTTON_ZR = 308, - CLASSIC_DPAD_UP = 309, - CLASSIC_DPAD_DOWN = 310, - CLASSIC_DPAD_LEFT = 311, - CLASSIC_DPAD_RIGHT = 312, - CLASSIC_STICK_LEFT = 313, // To Be Used on Java Side - CLASSIC_STICK_LEFT_UP = 314, - CLASSIC_STICK_LEFT_DOWN = 315, - CLASSIC_STICK_LEFT_LEFT = 316, - CLASSIC_STICK_LEFT_RIGHT = 317, - CLASSIC_STICK_RIGHT = 318, // To Be Used on Java Side - CLASSIC_STICK_RIGHT_UP = 319, - CLASSIC_STICK_RIGHT_DOWN = 320, - CLASSIC_STICK_RIGHT_LEFT = 321, - CLASSIC_STICK_RIGHT_RIGHT = 322, - CLASSIC_TRIGGER_L = 323, - CLASSIC_TRIGGER_R = 324, - // Guitar - GUITAR_BUTTON_MINUS = 400, - GUITAR_BUTTON_PLUS = 401, - GUITAR_FRET_GREEN = 402, - GUITAR_FRET_RED = 403, - GUITAR_FRET_YELLOW = 404, - GUITAR_FRET_BLUE = 405, - GUITAR_FRET_ORANGE = 406, - GUITAR_STRUM_UP = 407, - GUITAR_STRUM_DOWN = 408, - GUITAR_STICK = 409, // To Be Used on Java Side - GUITAR_STICK_UP = 410, - GUITAR_STICK_DOWN = 411, - GUITAR_STICK_LEFT = 412, - GUITAR_STICK_RIGHT = 413, - GUITAR_WHAMMY_BAR = 414, - // Drums - DRUMS_BUTTON_MINUS = 500, - DRUMS_BUTTON_PLUS = 501, - DRUMS_PAD_RED = 502, - DRUMS_PAD_YELLOW = 503, - DRUMS_PAD_BLUE = 504, - DRUMS_PAD_GREEN = 505, - DRUMS_PAD_ORANGE = 506, - DRUMS_PAD_BASS = 507, - DRUMS_STICK = 508, // To Be Used on Java Side - DRUMS_STICK_UP = 509, - DRUMS_STICK_DOWN = 510, - DRUMS_STICK_LEFT = 511, - DRUMS_STICK_RIGHT = 512, - // Turntable - TURNTABLE_BUTTON_GREEN_LEFT = 600, - TURNTABLE_BUTTON_RED_LEFT = 601, - TURNTABLE_BUTTON_BLUE_LEFT = 602, - TURNTABLE_BUTTON_GREEN_RIGHT = 603, - TURNTABLE_BUTTON_RED_RIGHT = 604, - TURNTABLE_BUTTON_BLUE_RIGHT = 605, - TURNTABLE_BUTTON_MINUS = 606, - TURNTABLE_BUTTON_PLUS = 607, - TURNTABLE_BUTTON_HOME = 608, - TURNTABLE_BUTTON_EUPHORIA = 609, - TURNTABLE_TABLE_LEFT = 610, // To Be Used on Java Side - TURNTABLE_TABLE_LEFT_LEFT = 611, - TURNTABLE_TABLE_LEFT_RIGHT = 612, - TURNTABLE_TABLE_RIGHT = 613, // To Be Used on Java Side - TURNTABLE_TABLE_RIGHT_LEFT = 614, - TURNTABLE_TABLE_RIGHT_RIGHT = 615, - TURNTABLE_STICK = 616, // To Be Used on Java Side - TURNTABLE_STICK_UP = 617, - TURNTABLE_STICK_DOWN = 618, - TURNTABLE_STICK_LEFT = 619, - TURNTABLE_STICK_RIGHT = 620, - TURNTABLE_EFFECT_DIAL = 621, - TURNTABLE_CROSSFADE = 622, // To Be Used on Java Side - TURNTABLE_CROSSFADE_LEFT = 623, - TURNTABLE_CROSSFADE_RIGHT = 624, - // Wiimote IMU - WIIMOTE_ACCEL_LEFT = 625, - WIIMOTE_ACCEL_RIGHT = 626, - WIIMOTE_ACCEL_FORWARD = 627, - WIIMOTE_ACCEL_BACKWARD = 628, - WIIMOTE_ACCEL_UP = 629, - WIIMOTE_ACCEL_DOWN = 630, - WIIMOTE_GYRO_PITCH_UP = 631, - WIIMOTE_GYRO_PITCH_DOWN = 632, - WIIMOTE_GYRO_ROLL_LEFT = 633, - WIIMOTE_GYRO_ROLL_RIGHT = 634, - WIIMOTE_GYRO_YAW_LEFT = 635, - WIIMOTE_GYRO_YAW_RIGHT = 636, - // Rumble - RUMBLE = 700, -}; -enum ButtonState -{ - BUTTON_RELEASED = 0, - BUTTON_PRESSED = 1 -}; -enum BindType -{ - BIND_BUTTON = 0, - BIND_AXIS -}; -class Button -{ -private: - ButtonState m_state; - -public: - Button() : m_state(BUTTON_RELEASED) {} - void SetState(ButtonState state) { m_state = state; } - bool Pressed() const { return m_state == BUTTON_PRESSED; } - ~Button() {} -}; -class Axis -{ -private: - float m_value; - -public: - Axis() : m_value(0.0f) {} - void SetValue(float value) { m_value = value; } - float AxisValue() const { return m_value; } - ~Axis() {} -}; - -struct sBind -{ - const int m_pad_id; - const ButtonType m_button_type; - const BindType m_bind_type; - const int m_bind; - const float m_neg; - sBind(int pad_id, ButtonType button_type, BindType bind_type, int bind, float neg) - : m_pad_id(pad_id), m_button_type(button_type), m_bind_type(bind_type), m_bind(bind), - m_neg(neg) - { - } -}; - -class InputDevice -{ -private: - const std::string m_dev; - std::map<ButtonType, bool> m_buttons; - std::map<ButtonType, float> m_axes; - - // Key is pad_id and ButtonType - std::map<std::pair<int, ButtonType>, sBind*> m_input_binds; - -public: - InputDevice(std::string dev) : m_dev(dev) {} - ~InputDevice() - { - for (const auto& bind : m_input_binds) - delete bind.second; - m_input_binds.clear(); - } - void AddBind(sBind* bind) - { - m_input_binds[std::make_pair(bind->m_pad_id, bind->m_button_type)] = bind; - } - bool PressEvent(int button, int action); - void AxisEvent(int axis, float value); - bool ButtonValue(int pad_id, ButtonType button) const; - float AxisValue(int pad_id, ButtonType axis) const; -}; - -void Init(const std::string&); - -// pad_id is numbered 0 to 3 for GC pads and 4 to 7 for Wiimotes -bool GetButtonPressed(int pad_id, ButtonType button); -float GetAxisValue(int pad_id, ButtonType axis); - -bool GamepadEvent(const std::string& dev, int button, int action); -void GamepadAxisEvent(const std::string& dev, int axis, float value); - -void Shutdown(); -} // namespace ButtonManager diff --git a/Source/Core/InputCommon/ControllerInterface/Touch/Touchscreen.cpp b/Source/Core/InputCommon/ControllerInterface/Touch/Touchscreen.cpp deleted file mode 100644 index a4c20b0ae0..0000000000 --- a/Source/Core/InputCommon/ControllerInterface/Touch/Touchscreen.cpp +++ /dev/null @@ -1,264 +0,0 @@ -// Copyright 2013 Dolphin Emulator Project -// SPDX-License-Identifier: GPL-2.0-or-later - -#include "InputCommon/ControllerInterface/Touch/Touchscreen.h" - -#include <sstream> -#include <thread> -#ifdef ANDROID -#include <jni/AndroidCommon/IDCache.h> -#endif - -#include "InputCommon/ControllerInterface/ControllerInterface.h" - -namespace ciface::Touch -{ -// Touchscreens and stuff -std::string Touchscreen::GetName() const -{ - return "Touchscreen"; -} - -std::string Touchscreen::GetSource() const -{ - return "Android"; -} - -Touchscreen::Touchscreen(int pad_id, bool accelerometer_enabled, bool gyroscope_enabled) - : m_pad_id(pad_id) -{ - // GC - AddInput(new Button(m_pad_id, ButtonManager::BUTTON_A)); - AddInput(new Button(m_pad_id, ButtonManager::BUTTON_B)); - AddInput(new Button(m_pad_id, ButtonManager::BUTTON_START)); - AddInput(new Button(m_pad_id, ButtonManager::BUTTON_X)); - AddInput(new Button(m_pad_id, ButtonManager::BUTTON_Y)); - AddInput(new Button(m_pad_id, ButtonManager::BUTTON_Z)); - AddInput(new Button(m_pad_id, ButtonManager::BUTTON_UP)); - AddInput(new Button(m_pad_id, ButtonManager::BUTTON_DOWN)); - AddInput(new Button(m_pad_id, ButtonManager::BUTTON_LEFT)); - AddInput(new Button(m_pad_id, ButtonManager::BUTTON_RIGHT)); - AddInput(new Axis(m_pad_id, ButtonManager::STICK_MAIN_LEFT)); - AddInput(new Axis(m_pad_id, ButtonManager::STICK_MAIN_RIGHT)); - AddInput(new Axis(m_pad_id, ButtonManager::STICK_MAIN_UP)); - AddInput(new Axis(m_pad_id, ButtonManager::STICK_MAIN_DOWN)); - AddInput(new Axis(m_pad_id, ButtonManager::STICK_C_LEFT)); - AddInput(new Axis(m_pad_id, ButtonManager::STICK_C_RIGHT)); - AddInput(new Axis(m_pad_id, ButtonManager::STICK_C_UP)); - AddInput(new Axis(m_pad_id, ButtonManager::STICK_C_DOWN)); - AddInput(new Axis(m_pad_id, ButtonManager::TRIGGER_L)); - AddInput(new Axis(m_pad_id, ButtonManager::TRIGGER_R)); - - // Wiimote - AddInput(new Button(m_pad_id, ButtonManager::WIIMOTE_BUTTON_A)); - AddInput(new Button(m_pad_id, ButtonManager::WIIMOTE_BUTTON_B)); - AddInput(new Button(m_pad_id, ButtonManager::WIIMOTE_BUTTON_MINUS)); - AddInput(new Button(m_pad_id, ButtonManager::WIIMOTE_BUTTON_PLUS)); - AddInput(new Button(m_pad_id, ButtonManager::WIIMOTE_BUTTON_HOME)); - AddInput(new Button(m_pad_id, ButtonManager::WIIMOTE_BUTTON_1)); - AddInput(new Button(m_pad_id, ButtonManager::WIIMOTE_BUTTON_2)); - AddInput(new Button(m_pad_id, ButtonManager::WIIMOTE_UP)); - AddInput(new Button(m_pad_id, ButtonManager::WIIMOTE_DOWN)); - AddInput(new Button(m_pad_id, ButtonManager::WIIMOTE_LEFT)); - AddInput(new Button(m_pad_id, ButtonManager::WIIMOTE_RIGHT)); - AddInput(new Button(m_pad_id, ButtonManager::WIIMOTE_IR_HIDE)); - AddInput(new Button(m_pad_id, ButtonManager::WIIMOTE_TILT_MODIFIER)); - AddInput(new Button(m_pad_id, ButtonManager::WIIMOTE_SHAKE_X)); - AddInput(new Button(m_pad_id, ButtonManager::WIIMOTE_SHAKE_Y)); - AddInput(new Button(m_pad_id, ButtonManager::WIIMOTE_SHAKE_Z)); - AddInput(new Axis(m_pad_id, ButtonManager::WIIMOTE_IR_UP)); - AddInput(new Axis(m_pad_id, ButtonManager::WIIMOTE_IR_DOWN)); - AddInput(new Axis(m_pad_id, ButtonManager::WIIMOTE_IR_LEFT)); - AddInput(new Axis(m_pad_id, ButtonManager::WIIMOTE_IR_RIGHT)); - AddInput(new Axis(m_pad_id, ButtonManager::WIIMOTE_IR_FORWARD)); - AddInput(new Axis(m_pad_id, ButtonManager::WIIMOTE_IR_BACKWARD)); - AddInput(new Axis(m_pad_id, ButtonManager::WIIMOTE_SWING_UP)); - AddInput(new Axis(m_pad_id, ButtonManager::WIIMOTE_SWING_DOWN)); - AddInput(new Axis(m_pad_id, ButtonManager::WIIMOTE_SWING_LEFT)); - AddInput(new Axis(m_pad_id, ButtonManager::WIIMOTE_SWING_RIGHT)); - AddInput(new Axis(m_pad_id, ButtonManager::WIIMOTE_SWING_FORWARD)); - AddInput(new Axis(m_pad_id, ButtonManager::WIIMOTE_SWING_BACKWARD)); - AddInput(new Axis(m_pad_id, ButtonManager::WIIMOTE_TILT_LEFT)); - AddInput(new Axis(m_pad_id, ButtonManager::WIIMOTE_TILT_RIGHT)); - AddInput(new Axis(m_pad_id, ButtonManager::WIIMOTE_TILT_FORWARD)); - AddInput(new Axis(m_pad_id, ButtonManager::WIIMOTE_TILT_BACKWARD)); - - // Wii ext: Nunchuk - AddInput(new Button(m_pad_id, ButtonManager::NUNCHUK_BUTTON_C)); - AddInput(new Button(m_pad_id, ButtonManager::NUNCHUK_BUTTON_Z)); - AddInput(new Button(m_pad_id, ButtonManager::NUNCHUK_TILT_MODIFIER)); - AddInput(new Button(m_pad_id, ButtonManager::NUNCHUK_SHAKE_X)); - AddInput(new Button(m_pad_id, ButtonManager::NUNCHUK_SHAKE_Y)); - AddInput(new Button(m_pad_id, ButtonManager::NUNCHUK_SHAKE_Z)); - AddInput(new Axis(m_pad_id, ButtonManager::NUNCHUK_STICK_LEFT)); - AddInput(new Axis(m_pad_id, ButtonManager::NUNCHUK_STICK_RIGHT)); - AddInput(new Axis(m_pad_id, ButtonManager::NUNCHUK_STICK_UP)); - AddInput(new Axis(m_pad_id, ButtonManager::NUNCHUK_STICK_DOWN)); - AddInput(new Axis(m_pad_id, ButtonManager::NUNCHUK_SWING_LEFT)); - AddInput(new Axis(m_pad_id, ButtonManager::NUNCHUK_SWING_RIGHT)); - AddInput(new Axis(m_pad_id, ButtonManager::NUNCHUK_SWING_UP)); - AddInput(new Axis(m_pad_id, ButtonManager::NUNCHUK_SWING_DOWN)); - AddInput(new Axis(m_pad_id, ButtonManager::NUNCHUK_SWING_FORWARD)); - AddInput(new Axis(m_pad_id, ButtonManager::NUNCHUK_SWING_BACKWARD)); - AddInput(new Axis(m_pad_id, ButtonManager::NUNCHUK_TILT_LEFT)); - AddInput(new Axis(m_pad_id, ButtonManager::NUNCHUK_TILT_RIGHT)); - AddInput(new Axis(m_pad_id, ButtonManager::NUNCHUK_TILT_FORWARD)); - AddInput(new Axis(m_pad_id, ButtonManager::NUNCHUK_TILT_BACKWARD)); - - // Wii ext: Classic - AddInput(new Button(m_pad_id, ButtonManager::CLASSIC_BUTTON_A)); - AddInput(new Button(m_pad_id, ButtonManager::CLASSIC_BUTTON_B)); - AddInput(new Button(m_pad_id, ButtonManager::CLASSIC_BUTTON_X)); - AddInput(new Button(m_pad_id, ButtonManager::CLASSIC_BUTTON_Y)); - AddInput(new Button(m_pad_id, ButtonManager::CLASSIC_BUTTON_MINUS)); - AddInput(new Button(m_pad_id, ButtonManager::CLASSIC_BUTTON_PLUS)); - AddInput(new Button(m_pad_id, ButtonManager::CLASSIC_BUTTON_HOME)); - AddInput(new Button(m_pad_id, ButtonManager::CLASSIC_BUTTON_ZL)); - AddInput(new Button(m_pad_id, ButtonManager::CLASSIC_BUTTON_ZR)); - AddInput(new Button(m_pad_id, ButtonManager::CLASSIC_DPAD_UP)); - AddInput(new Button(m_pad_id, ButtonManager::CLASSIC_DPAD_DOWN)); - AddInput(new Button(m_pad_id, ButtonManager::CLASSIC_DPAD_LEFT)); - AddInput(new Button(m_pad_id, ButtonManager::CLASSIC_DPAD_RIGHT)); - AddInput(new Axis(m_pad_id, ButtonManager::CLASSIC_STICK_LEFT_LEFT)); - AddInput(new Axis(m_pad_id, ButtonManager::CLASSIC_STICK_LEFT_RIGHT)); - AddInput(new Axis(m_pad_id, ButtonManager::CLASSIC_STICK_LEFT_UP)); - AddInput(new Axis(m_pad_id, ButtonManager::CLASSIC_STICK_LEFT_DOWN)); - AddInput(new Axis(m_pad_id, ButtonManager::CLASSIC_STICK_RIGHT_LEFT)); - AddInput(new Axis(m_pad_id, ButtonManager::CLASSIC_STICK_RIGHT_RIGHT)); - AddInput(new Axis(m_pad_id, ButtonManager::CLASSIC_STICK_RIGHT_UP)); - AddInput(new Axis(m_pad_id, ButtonManager::CLASSIC_STICK_RIGHT_DOWN)); - AddInput(new Axis(m_pad_id, ButtonManager::CLASSIC_TRIGGER_L)); - AddInput(new Axis(m_pad_id, ButtonManager::CLASSIC_TRIGGER_R)); - - // Wii-ext: Guitar - AddInput(new Button(m_pad_id, ButtonManager::GUITAR_BUTTON_MINUS)); - AddInput(new Button(m_pad_id, ButtonManager::GUITAR_BUTTON_PLUS)); - AddInput(new Button(m_pad_id, ButtonManager::GUITAR_FRET_GREEN)); - AddInput(new Button(m_pad_id, ButtonManager::GUITAR_FRET_RED)); - AddInput(new Button(m_pad_id, ButtonManager::GUITAR_FRET_YELLOW)); - AddInput(new Button(m_pad_id, ButtonManager::GUITAR_FRET_BLUE)); - AddInput(new Button(m_pad_id, ButtonManager::GUITAR_FRET_ORANGE)); - AddInput(new Button(m_pad_id, ButtonManager::GUITAR_STRUM_UP)); - AddInput(new Button(m_pad_id, ButtonManager::GUITAR_STRUM_DOWN)); - AddInput(new Axis(m_pad_id, ButtonManager::GUITAR_STICK_LEFT)); - AddInput(new Axis(m_pad_id, ButtonManager::GUITAR_STICK_RIGHT)); - AddInput(new Axis(m_pad_id, ButtonManager::GUITAR_STICK_UP)); - AddInput(new Axis(m_pad_id, ButtonManager::GUITAR_STICK_DOWN)); - AddInput(new Axis(m_pad_id, ButtonManager::GUITAR_WHAMMY_BAR)); - - // Wii-ext: Drums - AddInput(new Button(m_pad_id, ButtonManager::DRUMS_BUTTON_MINUS)); - AddInput(new Button(m_pad_id, ButtonManager::DRUMS_BUTTON_PLUS)); - AddInput(new Button(m_pad_id, ButtonManager::DRUMS_PAD_RED)); - AddInput(new Button(m_pad_id, ButtonManager::DRUMS_PAD_YELLOW)); - AddInput(new Button(m_pad_id, ButtonManager::DRUMS_PAD_BLUE)); - AddInput(new Button(m_pad_id, ButtonManager::DRUMS_PAD_GREEN)); - AddInput(new Button(m_pad_id, ButtonManager::DRUMS_PAD_ORANGE)); - AddInput(new Button(m_pad_id, ButtonManager::DRUMS_PAD_BASS)); - AddInput(new Axis(m_pad_id, ButtonManager::DRUMS_STICK_LEFT)); - AddInput(new Axis(m_pad_id, ButtonManager::DRUMS_STICK_RIGHT)); - AddInput(new Axis(m_pad_id, ButtonManager::DRUMS_STICK_UP)); - AddInput(new Axis(m_pad_id, ButtonManager::DRUMS_STICK_DOWN)); - - // Wii-ext: Turntable - AddInput(new Button(m_pad_id, ButtonManager::TURNTABLE_BUTTON_GREEN_LEFT)); - AddInput(new Button(m_pad_id, ButtonManager::TURNTABLE_BUTTON_RED_LEFT)); - AddInput(new Button(m_pad_id, ButtonManager::TURNTABLE_BUTTON_BLUE_LEFT)); - AddInput(new Button(m_pad_id, ButtonManager::TURNTABLE_BUTTON_GREEN_RIGHT)); - AddInput(new Button(m_pad_id, ButtonManager::TURNTABLE_BUTTON_RED_RIGHT)); - AddInput(new Button(m_pad_id, ButtonManager::TURNTABLE_BUTTON_BLUE_RIGHT)); - AddInput(new Button(m_pad_id, ButtonManager::TURNTABLE_BUTTON_MINUS)); - AddInput(new Button(m_pad_id, ButtonManager::TURNTABLE_BUTTON_PLUS)); - AddInput(new Button(m_pad_id, ButtonManager::TURNTABLE_BUTTON_HOME)); - AddInput(new Button(m_pad_id, ButtonManager::TURNTABLE_BUTTON_EUPHORIA)); - AddInput(new Axis(m_pad_id, ButtonManager::TURNTABLE_TABLE_LEFT_LEFT)); - AddInput(new Axis(m_pad_id, ButtonManager::TURNTABLE_TABLE_LEFT_RIGHT)); - AddInput(new Axis(m_pad_id, ButtonManager::TURNTABLE_TABLE_RIGHT_LEFT)); - AddInput(new Axis(m_pad_id, ButtonManager::TURNTABLE_TABLE_RIGHT_RIGHT)); - AddInput(new Axis(m_pad_id, ButtonManager::TURNTABLE_STICK_LEFT)); - AddInput(new Axis(m_pad_id, ButtonManager::TURNTABLE_STICK_RIGHT)); - AddInput(new Axis(m_pad_id, ButtonManager::TURNTABLE_STICK_UP)); - AddInput(new Axis(m_pad_id, ButtonManager::TURNTABLE_STICK_DOWN)); - AddInput(new Axis(m_pad_id, ButtonManager::TURNTABLE_CROSSFADE_LEFT)); - AddInput(new Axis(m_pad_id, ButtonManager::TURNTABLE_CROSSFADE_RIGHT)); - AddInput(new Axis(m_pad_id, ButtonManager::TURNTABLE_EFFECT_DIAL)); - - // Wiimote IMU - // Only add inputs if we actually can receive data from the relevant sensor. - // Whether inputs exist affects what WiimoteEmu gets when calling ControlReference::BoundCount. - if (accelerometer_enabled) - { - AddInput(new Axis(m_pad_id, ButtonManager::WIIMOTE_ACCEL_LEFT)); - AddInput(new Axis(m_pad_id, ButtonManager::WIIMOTE_ACCEL_RIGHT)); - AddInput(new Axis(m_pad_id, ButtonManager::WIIMOTE_ACCEL_FORWARD)); - AddInput(new Axis(m_pad_id, ButtonManager::WIIMOTE_ACCEL_BACKWARD)); - AddInput(new Axis(m_pad_id, ButtonManager::WIIMOTE_ACCEL_UP)); - AddInput(new Axis(m_pad_id, ButtonManager::WIIMOTE_ACCEL_DOWN)); - } - if (gyroscope_enabled) - { - AddInput(new Axis(m_pad_id, ButtonManager::WIIMOTE_GYRO_PITCH_UP)); - AddInput(new Axis(m_pad_id, ButtonManager::WIIMOTE_GYRO_PITCH_DOWN)); - AddInput(new Axis(m_pad_id, ButtonManager::WIIMOTE_GYRO_ROLL_LEFT)); - AddInput(new Axis(m_pad_id, ButtonManager::WIIMOTE_GYRO_ROLL_RIGHT)); - AddInput(new Axis(m_pad_id, ButtonManager::WIIMOTE_GYRO_YAW_LEFT)); - AddInput(new Axis(m_pad_id, ButtonManager::WIIMOTE_GYRO_YAW_RIGHT)); - } - - // Rumble - AddOutput(new Motor(m_pad_id, ButtonManager::RUMBLE)); -} -// Buttons and stuff - -std::string Touchscreen::Button::GetName() const -{ - std::ostringstream ss; - ss << "Button " << static_cast<int>(m_index); - return ss.str(); -} - -ControlState Touchscreen::Button::GetState() const -{ - return ButtonManager::GetButtonPressed(m_pad_id, m_index); -} - -std::string Touchscreen::Axis::GetName() const -{ - std::ostringstream ss; - ss << "Axis " << static_cast<int>(m_index); - return ss.str(); -} - -ControlState Touchscreen::Axis::GetState() const -{ - return ButtonManager::GetAxisValue(m_pad_id, m_index) * m_neg; -} - -Touchscreen::Motor::~Motor() -{ -} - -std::string Touchscreen::Motor::GetName() const -{ - std::ostringstream ss; - ss << "Rumble " << static_cast<int>(m_index); - return ss.str(); -} - -void Touchscreen::Motor::SetState(ControlState state) -{ - if (state > 0) - { - std::thread(Rumble, m_pad_id, state).detach(); - } -} - -void Touchscreen::Motor::Rumble(int pad_id, double state) -{ -#ifdef ANDROID - JNIEnv* env = IDCache::GetEnvForThread(); - env->CallStaticVoidMethod(IDCache::GetNativeLibraryClass(), IDCache::GetDoRumble(), pad_id, - state); -#endif -} -} // namespace ciface::Touch diff --git a/Source/Core/InputCommon/ControllerInterface/Touch/Touchscreen.h b/Source/Core/InputCommon/ControllerInterface/Touch/Touchscreen.h deleted file mode 100644 index 9d12df1a4c..0000000000 --- a/Source/Core/InputCommon/ControllerInterface/Touch/Touchscreen.h +++ /dev/null @@ -1,64 +0,0 @@ -// Copyright 2008 Dolphin Emulator Project -// SPDX-License-Identifier: GPL-2.0-or-later - -#pragma once - -#include "InputCommon/ControllerInterface/ControllerInterface.h" -#include "InputCommon/ControllerInterface/Touch/ButtonManager.h" - -namespace ciface::Touch -{ -class Touchscreen : public Core::Device -{ -private: - class Button : public Input - { - public: - std::string GetName() const override; - Button(int pad_id, ButtonManager::ButtonType index) : m_pad_id(pad_id), m_index(index) {} - ControlState GetState() const override; - - private: - const int m_pad_id; - const ButtonManager::ButtonType m_index; - }; - class Axis : public Input - { - public: - std::string GetName() const override; - bool IsDetectable() const override { return false; } - Axis(int pad_id, ButtonManager::ButtonType index, float neg = 1.0f) - : m_pad_id(pad_id), m_index(index), m_neg(neg) - { - } - ControlState GetState() const override; - - private: - const int m_pad_id; - const ButtonManager::ButtonType m_index; - const float m_neg; - }; - class Motor : public Core::Device::Output - { - public: - Motor(int pad_id, ButtonManager::ButtonType index) : m_pad_id(pad_id), m_index(index) {} - ~Motor(); - std::string GetName() const override; - void SetState(ControlState state) override; - - private: - const int m_pad_id; - const ButtonManager::ButtonType m_index; - static void Rumble(int pad_id, double state); - }; - -public: - Touchscreen(int pad_id, bool accelerometer_enabled, bool gyroscope_enabled); - ~Touchscreen() {} - std::string GetName() const override; - std::string GetSource() const override; - -private: - const int m_pad_id; -}; -} // namespace ciface::Touch |