int DInputPad::TokenIn(uint8_t *buf, int len)
{
int range = range_max(mType);
// Setting to unpressed
ZeroMemory(&mWheelData, sizeof(wheel_data_t));
mWheelData.steering = range >> 1;
mWheelData.clutch = 0xFF;
mWheelData.throttle = 0xFF;
mWheelData.brake = 0xFF;
mWheelData.hatswitch = 0x8;
//TODO Atleast GT4 detects DFP then
if(sendCrap)
{
pad_copy_data(mType, buf, mWheelData);
sendCrap = false;
return len;
}
PollDevices();
//Allow in both ports but warn in configure dialog that only one DX wheel is supported for now
//if(idx == 0){
//mWheelData.steering = 8191 + (int)(GetControl(STEERING, false)* 8191.0f) ;
if(calibrating){
//Alternate full extents
if (alternate)calidata--;
else calidata++;
if(calidata>range-1 || calidata < 1) alternate = !alternate; //invert
mWheelData.steering = calidata; //pass fake
//breakout after 11 seconds
if(GetTickCount()-calibrationtime > 11000){
calibrating = false;
mWheelData.steering = range >> 1;
}
}else{
static int usb_pad_poll(PADState *ps, uint8_t *buf, int buflen)
{
LinuxPADState *s = (LinuxPADState*)ps;
uint8_t idx = 1 - s->padState.port;
ssize_t len;
if(idx > 1) return 0; //invalid port
int range = range_max(idx);
if(sendCrap)
{
// Setting to unpressed
memset(&wheel_data, 0, sizeof(wheel_data_t));
wheel_data.axis_x = range >> 1;
wheel_data.axis_y = 0xFF;
wheel_data.axis_z = 0xFF;
wheel_data.axis_rz = 0xFF;
wheel_data.hatswitch = 0x8;
pad_copy_data(idx, buf, wheel_data);
sendCrap = false;
return len;
}
// Events are raised if state changes, so keep old generic_data intact
//memset(&wheel_data, 0, sizeof(wheel_data_t));
struct js_event event;
int wtype = conf.WheelType[idx];
//Non-blocking read sets len to -1 and errno to EAGAIN if no new data
//TODO what happens when emulator is paused?
while((len = read(s->fd, &event, sizeof(event))) > -1)
{
//Dbg("Read js len: %d %d\n", len, errno);
if (len == sizeof(event))
{ // ok
if (event.type & JS_EVENT_AXIS)
{
//Dbg("Axis: %d, %d\n", event.number, event.value);
switch(s->axismap[event.number])
{
case ABS_X: wheel_data.axis_x = NORM(event.value, range); break;
case ABS_Y: wheel_data.axis_y = NORM(event.value, 0xFF); break;
case ABS_Z: wheel_data.axis_z = NORM(event.value, 0xFF); break;
//case ABS_RX: wheel_data.axis_rx = NORM(event.value, 0xFF); break;
//case ABS_RY: wheel_data.axis_ry = NORM(event.value, 0xFF); break;
case ABS_RZ: wheel_data.axis_rz = NORM(event.value, 0xFF); break;
//FIXME hatswitch mapping
//TODO Ignoring diagonal directions
case ABS_HAT0X:
case ABS_HAT1X:
if(event.value < 0 ) //left usually
wheel_data.hatswitch = PAD_HAT_W;
else if(event.value > 0 ) //right
wheel_data.hatswitch = PAD_HAT_E;
else
wheel_data.hatswitch = PAD_HAT_COUNT;
break;
case ABS_HAT0Y:
case ABS_HAT1Y:
if(event.value < 0 ) //up usually
wheel_data.hatswitch = PAD_HAT_N;
else if(event.value > 0 ) //down
wheel_data.hatswitch = PAD_HAT_S;
else
wheel_data.hatswitch = PAD_HAT_COUNT;
break;
default: break;
}
}
else if (event.type & JS_EVENT_BUTTON)
{
//Dbg("Button: %d, %d\n", event.number, event.value);
//TODO can have 12 bits for buttons?
if(event.number < 10)
{
//FIXME bit juggling
if(event.value)
wheel_data.buttons |= 1 << event.number; //on
else
wheel_data.buttons &= ~(1 << event.number); //off
}
}
}
else
{
Dbg("usb_pad_poll: unknown read error\n");
break;
}
}
//Dbg("call pad_copy_data\n");
pad_copy_data(idx, buf, wheel_data);
return buflen;
}
int RawInputPad::TokenIn(uint8_t *buf, int len)
{
uint8_t data[64];
DWORD waitRes;
ULONG value = 0;
int ply = 1 - mPort;
//fprintf(stderr,"usb-pad: poll len=%li\n", len);
if(this->doPassthrough && this->usbHandle != INVALID_HANDLE_VALUE)
{
//ZeroMemory(buf, len);
ReadFile(this->usbHandle, data, MIN(this->caps.InputReportByteLength, sizeof(data)), 0, &this->ovl);
waitRes = WaitForSingleObject(this->ovl.hEvent, 50);
if(waitRes == WAIT_TIMEOUT || waitRes == WAIT_ABANDONED){
CancelIo(this->usbHandle);
return 0;
}
memcpy(buf, data, len);
return len;
}
//in case compiler magic with bitfields interferes
wheel_data_t data_summed;
memset(&data_summed, 0xFF, sizeof(data_summed));
data_summed.hatswitch = 0x8;
data_summed.buttons = 0;
//TODO Atleast GT4 detects DFP then
if(sendCrap)
{
sendCrap = false;
pad_copy_data(mType, buf, data_summed);
return len;
}
int copied = 0;
//TODO fix the logics, also Config.cpp
MapVector::iterator it = mapVector.begin();
for(; it!=mapVector.end(); it++)
{
if (data_summed.steering < (*it).data[ply].steering)
{
data_summed.steering = (*it).data[ply].steering;
copied |= 1;
}
//if(data_summed.clutch < (*it).data[ply].clutch)
// data_summed.clutch = (*it).data[ply].clutch;
if (data_summed.throttle < (*it).data[ply].throttle)
{
data_summed.throttle = (*it).data[ply].throttle;
copied |= 2;
}
if (data_summed.brake < (*it).data[ply].brake)
{
data_summed.brake = (*it).data[ply].brake;
copied |= 4;
}
data_summed.buttons |= (*it).data[ply].buttons;
if(data_summed.hatswitch > (*it).data[ply].hatswitch)
data_summed.hatswitch = (*it).data[ply].hatswitch;
}
if (!copied)
memcpy(&data_summed, &mDataCopy, sizeof(wheel_data_t));
else
{
if (!(copied & 1))
data_summed.steering = mDataCopy.steering;
if (!(copied & 2))
data_summed.throttle = mDataCopy.throttle;
if (!(copied & 4))
data_summed.brake = mDataCopy.brake;
}
pad_copy_data(mType, buf, data_summed);
if (copied)
memcpy(&mDataCopy, &data_summed, sizeof(wheel_data_t));
return len;
}
