270 lines
10 KiB
C++
270 lines
10 KiB
C++
#if PLATFORM_LINUX
|
|
|
|
#include <iostream>
|
|
#include <fstream>
|
|
#include <sstream>
|
|
#include <unistd.h>
|
|
#include <fcntl.h>
|
|
#include "LinuxInput.h"
|
|
#include "Engine/Core/Log.h"
|
|
|
|
using namespace std;
|
|
|
|
struct LinuxInputDevice {
|
|
u_int32_t uid[4];
|
|
string name;
|
|
string handler;
|
|
bool isGamepad;
|
|
};
|
|
|
|
static int foundGamepads;
|
|
static float lastUpdateTime;
|
|
static LinuxInputDevice inputDevices[LINUXINPUT_MAX_GAMEPADS];
|
|
static LinuxGamepad *linuxGamepads[LINUXINPUT_MAX_GAMEPADS];
|
|
|
|
void LinuxInput::Init() {
|
|
for (int i = 0; i < LINUXINPUT_MAX_GAMEPADS; i++)
|
|
{
|
|
linuxGamepads[i] = nullptr;
|
|
}
|
|
foundGamepads = 0;
|
|
// this will delay gamepad detection
|
|
lastUpdateTime = Platform::GetTimeSeconds();
|
|
}
|
|
|
|
void LinuxInput::DetectGamePads()
|
|
{
|
|
string line;
|
|
std::ifstream devs("/proc/bus/input/devices");
|
|
|
|
foundGamepads = 0;
|
|
if (devs.is_open())
|
|
{
|
|
while (getline(devs, line))
|
|
{
|
|
if (line[0] == 'N')
|
|
{
|
|
int quoteIndex = line.find('"');
|
|
inputDevices[foundGamepads].name = line.substr(quoteIndex+1, line.length() - quoteIndex - 2);
|
|
} else if (line[0] == 'I')
|
|
{
|
|
int startIndex = 0;
|
|
for (int i = 0; i < 4; i++) {
|
|
int equalsIndex = line.find('=', startIndex);
|
|
if (equalsIndex > 0) {
|
|
istringstream part(line.substr(equalsIndex+1, 4));
|
|
part >> std::hex >> inputDevices[foundGamepads].uid[i];
|
|
}
|
|
startIndex = equalsIndex+1;
|
|
}
|
|
} else if (line[0] == 'H')
|
|
{
|
|
int eventIndex = line.find("event");
|
|
if (eventIndex > 0) {
|
|
int end = line.find(' ', eventIndex);
|
|
if (end > 0) {
|
|
inputDevices[foundGamepads].handler = "/dev/input/" + line.substr(eventIndex, end - eventIndex);
|
|
}
|
|
}
|
|
} else if (line[0] == 'B')
|
|
{
|
|
int keyIndex = line.find("KEY=");
|
|
if (keyIndex >= 0) {
|
|
// there should be five groups of 64 bits each
|
|
std::istringstream group(line.substr(keyIndex+4));
|
|
unsigned long int n64, msb;
|
|
int foundGroups = 0;
|
|
for (int i = 0; i < 5; i++)
|
|
{
|
|
group >> std::hex >> n64;
|
|
if (i == 0) msb = n64;
|
|
foundGroups++;
|
|
if (group.eof()) break;
|
|
}
|
|
if (foundGroups < 5) msb = 0;
|
|
inputDevices[foundGamepads].isGamepad = (msb & 1lu<<48) > 0;
|
|
|
|
}
|
|
} else if (line.length() == 0)
|
|
{
|
|
if (inputDevices[foundGamepads].isGamepad && foundGamepads < (LINUXINPUT_MAX_GAMEPADS-1))
|
|
{
|
|
foundGamepads++;
|
|
}
|
|
}
|
|
}
|
|
devs.close();
|
|
}
|
|
//DumpDevices();
|
|
};
|
|
|
|
void LinuxInput::UpdateState()
|
|
{
|
|
const float time = (float)Platform::GetTimeSeconds();
|
|
if (time - lastUpdateTime > 5.0f)
|
|
{
|
|
DetectGamePads();
|
|
lastUpdateTime = time;
|
|
for (int i = 0; i < foundGamepads; i++)
|
|
{
|
|
if (linuxGamepads[i] == nullptr)
|
|
{
|
|
linuxGamepads[i] = new LinuxGamepad(inputDevices[i].uid, inputDevices[i].name);
|
|
linuxGamepads[i]->dev = inputDevices[i].handler;
|
|
linuxGamepads[i]->fd = -1;
|
|
Input::Gamepads.Add(linuxGamepads[i]);
|
|
Input::OnGamepadsChanged();
|
|
LOG(Info, "Gamepad {} added", linuxGamepads[i]->GetName());
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// from WindowsInput.cpp
|
|
float NormalizeInputAxis(const int axisVal)
|
|
{
|
|
// Normalize [-32768..32767] -> [-1..1]
|
|
const float norm = axisVal <= 0 ? 32768.0f : 32767.0f;
|
|
return float(axisVal) / norm;
|
|
}
|
|
|
|
float NormalizeInputTrigger(const int axisVal)
|
|
{
|
|
// Normalize [-1023..1023] -> [-1..1]
|
|
return float(axisVal) / 1023.0f;
|
|
}
|
|
|
|
LinuxGamepad::LinuxGamepad(u_int32_t uid[4], string name) : Gamepad(Guid(uid[0], uid[1], uid[2], uid[3]), String(name.c_str()))
|
|
{
|
|
fd = -1;
|
|
for (int i = 0; i < (int32)GamepadButton::MAX; i++)
|
|
{
|
|
_state.Buttons[i] = 0;
|
|
}
|
|
for (int i = 0; i < (int32)GamepadAxis::MAX; i++)
|
|
{
|
|
_state.Axis[i] = 0;
|
|
}
|
|
}
|
|
|
|
LinuxGamepad::~LinuxGamepad()
|
|
{
|
|
if (fd >= 0) close(fd);
|
|
}
|
|
|
|
bool LinuxGamepad::UpdateState()
|
|
{
|
|
if (fd < 0)
|
|
{
|
|
fd = open(dev.c_str(), O_RDONLY|O_NONBLOCK);
|
|
//cout << "opened " << dev << endl;
|
|
}
|
|
input_event event;
|
|
int caughtEvents = 0;
|
|
for (int i = 0; i < LINUXINPUT_MAX_GAMEPAD_EVENTS_PER_FRAME; i++)
|
|
{
|
|
ssize_t r = read(fd, &event, sizeof(event));
|
|
if (r < 0)
|
|
{
|
|
if (errno != EAGAIN) {
|
|
LOG(Warning, "Lost connection to gamepad, errno={0}", errno);
|
|
close(fd);
|
|
fd = -1;
|
|
}
|
|
break;
|
|
}
|
|
if (r == 0) break;
|
|
if (r < sizeof(event) || r != 24)
|
|
{
|
|
LOG(Warning, "got a shortened package from the kernel {0}", r);
|
|
break;
|
|
}
|
|
if (event.type > EV_MAX)
|
|
{
|
|
LOG(Warning, "got an invalid event type from the kernel {0}", event.type);
|
|
break;
|
|
}
|
|
caughtEvents++;
|
|
//cout << "got an event " << event.type << ", code " << event.code << ", value " << event.value << endl;
|
|
if (event.type == EV_KEY)
|
|
{
|
|
switch (event.code) {
|
|
case BTN_A: _state.Buttons[(int32)GamepadButton::A] = !!event.value; break;
|
|
case BTN_B: _state.Buttons[(int32)GamepadButton::B] = !!event.value; break;
|
|
case BTN_X: _state.Buttons[(int32)GamepadButton::X] = !!event.value; break;
|
|
case BTN_Y: _state.Buttons[(int32)GamepadButton::Y] = !!event.value; break;
|
|
case BTN_TL: _state.Buttons[(int32)GamepadButton::LeftShoulder] = !!event.value; break;
|
|
case BTN_TR: _state.Buttons[(int32)GamepadButton::RightShoulder] = !!event.value; break;
|
|
case BTN_BACK: _state.Buttons[(int32)GamepadButton::Back] = !!event.value; break;
|
|
case BTN_START: _state.Buttons[(int32)GamepadButton::Start] = !!event.value; break;
|
|
case BTN_THUMBL: _state.Buttons[(int32)GamepadButton::LeftThumb] = !!event.value; break;
|
|
case BTN_THUMBR: _state.Buttons[(int32)GamepadButton::RightThumb] = !!event.value; break;
|
|
case BTN_DPAD_UP: _state.Buttons[(int32)GamepadButton::DPadUp] = !!event.value; break;
|
|
case BTN_DPAD_DOWN: _state.Buttons[(int32)GamepadButton::DPadDown] = !!event.value; break;
|
|
case BTN_DPAD_LEFT: _state.Buttons[(int32)GamepadButton::DPadLeft] = !!event.value; break;
|
|
case BTN_DPAD_RIGHT: _state.Buttons[(int32)GamepadButton::DPadRight] = !!event.value; break;
|
|
}
|
|
} else if (event.type == EV_ABS)
|
|
{
|
|
switch (event.code) {
|
|
case ABS_X:
|
|
_state.Axis[(int32)GamepadAxis::LeftStickX] = NormalizeInputAxis(event.value);
|
|
_state.Buttons[(int32)GamepadButton::LeftStickLeft] = event.value < -TRIGGER_THRESHOLD;
|
|
_state.Buttons[(int32)GamepadButton::LeftStickRight] = event.value > TRIGGER_THRESHOLD;
|
|
break;
|
|
case ABS_Y:
|
|
_state.Axis[(int32)GamepadAxis::LeftStickY] = NormalizeInputAxis(event.value);
|
|
_state.Buttons[(int32)GamepadButton::LeftStickUp] = event.value < -TRIGGER_THRESHOLD;
|
|
_state.Buttons[(int32)GamepadButton::LeftStickDown] = event.value > TRIGGER_THRESHOLD;
|
|
break;
|
|
case ABS_Z:
|
|
_state.Axis[(int32)GamepadAxis::LeftTrigger] = NormalizeInputTrigger(event.value);
|
|
_state.Buttons[(int32)GamepadButton::LeftTrigger] = event.value > 2;
|
|
break;
|
|
case ABS_RX:
|
|
_state.Axis[(int32)GamepadAxis::RightStickX] = NormalizeInputAxis(event.value);
|
|
_state.Buttons[(int32)GamepadButton::RightStickLeft] = event.value < -TRIGGER_THRESHOLD;
|
|
_state.Buttons[(int32)GamepadButton::RightStickRight] = event.value > TRIGGER_THRESHOLD;
|
|
break;
|
|
case ABS_RY:
|
|
_state.Axis[(int32)GamepadAxis::RightStickY] = NormalizeInputAxis(event.value);
|
|
_state.Buttons[(int32)GamepadButton::RightStickUp] = event.value < -TRIGGER_THRESHOLD;
|
|
_state.Buttons[(int32)GamepadButton::RightStickDown] = event.value > TRIGGER_THRESHOLD;
|
|
break;
|
|
case ABS_RZ:
|
|
_state.Axis[(int32)GamepadAxis::RightTrigger] = NormalizeInputTrigger(event.value);
|
|
_state.Buttons[(int32)GamepadButton::RightTrigger] = event.value > 2;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
/*
|
|
if (caughtEvents > 0)
|
|
{
|
|
LOG(Info, "Caught events: {}", caughtEvents);
|
|
cout << "left stick x: " << _state.Axis[(int32)GamepadAxis::LeftStickX] << endl;
|
|
cout << "left stick y: " << _state.Axis[(int32)GamepadAxis::LeftStickY] << endl;
|
|
cout << "left trigger: " << _state.Axis[(int32)GamepadAxis::LeftTrigger] << endl;
|
|
cout << "right stick x: " << _state.Axis[(int32)GamepadAxis::RightStickX] << endl;
|
|
cout << "right stick y: " << _state.Axis[(int32)GamepadAxis::RightStickY] << endl;
|
|
cout << "right trigger: " << _state.Axis[(int32)GamepadAxis::RightTrigger] << endl;
|
|
cout << "button A: " << _state.Buttons[(int32)GamepadButton::A] << endl;
|
|
cout << "layout A: " << (int32)Layout.Buttons[(int32)GamepadButton::A] << endl;
|
|
}
|
|
*/
|
|
return false;
|
|
}
|
|
|
|
void LinuxInput::DumpDevices()
|
|
{
|
|
for (int i = 0; i < foundGamepads; i++) {
|
|
char buf[36];
|
|
snprintf(buf, 36, "%04x %04x %04x %04x", inputDevices[i].uid[0], inputDevices[i].uid[1], inputDevices[i].uid[2], inputDevices[i].uid[3]);
|
|
cout << buf << endl;
|
|
cout << inputDevices[i].name << endl;
|
|
cout << inputDevices[i].handler << endl;
|
|
cout << (inputDevices[i].isGamepad ? "Gamepad" : "other") << endl;
|
|
}
|
|
}
|
|
|
|
#endif |