mirror of
https://github.com/RPCSX/rpcsx.git
synced 2025-12-06 07:12:14 +01:00
276 lines
7.1 KiB
C++
276 lines
7.1 KiB
C++
#include "stdafx.h"
|
|
#include "GameTablet.h"
|
|
#include "MouseHandler.h"
|
|
#include "Emu/IdManager.h"
|
|
#include "Emu/Cell/lv2/sys_usbd.h"
|
|
#include "Emu/system_config.h"
|
|
#include "Input/pad_thread.h"
|
|
|
|
LOG_CHANNEL(gametablet_log);
|
|
|
|
usb_device_gametablet::usb_device_gametablet(const std::array<u8, 7>& location)
|
|
: usb_device_emulated(location)
|
|
{
|
|
device = UsbDescriptorNode(USB_DESCRIPTOR_DEVICE,
|
|
UsbDeviceDescriptor {
|
|
.bcdUSB = 0x0200,
|
|
.bDeviceClass = 0x00,
|
|
.bDeviceSubClass = 0x00,
|
|
.bDeviceProtocol = 0x00,
|
|
.bMaxPacketSize0 = 0x08,
|
|
.idVendor = 0x20d6,
|
|
.idProduct = 0xcb17,
|
|
.bcdDevice = 0x0108,
|
|
.iManufacturer = 0x01,
|
|
.iProduct = 0x02,
|
|
.iSerialNumber = 0x00,
|
|
.bNumConfigurations = 0x01});
|
|
auto& config0 = device.add_node(UsbDescriptorNode(USB_DESCRIPTOR_CONFIG,
|
|
UsbDeviceConfiguration {
|
|
.wTotalLength = 0x0029,
|
|
.bNumInterfaces = 0x01,
|
|
.bConfigurationValue = 0x01,
|
|
.iConfiguration = 0x00,
|
|
.bmAttributes = 0x80,
|
|
.bMaxPower = 0x32}));
|
|
config0.add_node(UsbDescriptorNode(USB_DESCRIPTOR_INTERFACE,
|
|
UsbDeviceInterface {
|
|
.bInterfaceNumber = 0x00,
|
|
.bAlternateSetting = 0x00,
|
|
.bNumEndpoints = 0x02,
|
|
.bInterfaceClass = 0x03,
|
|
.bInterfaceSubClass = 0x00,
|
|
.bInterfaceProtocol = 0x00,
|
|
.iInterface = 0x00}));
|
|
config0.add_node(UsbDescriptorNode(USB_DESCRIPTOR_HID,
|
|
UsbDeviceHID {
|
|
.bcdHID = 0x0110,
|
|
.bCountryCode = 0x00,
|
|
.bNumDescriptors = 0x01,
|
|
.bDescriptorType = 0x22,
|
|
.wDescriptorLength = 0x0089}));
|
|
config0.add_node(UsbDescriptorNode(USB_DESCRIPTOR_ENDPOINT,
|
|
UsbDeviceEndpoint {
|
|
.bEndpointAddress = 0x83,
|
|
.bmAttributes = 0x03,
|
|
.wMaxPacketSize = 0x0040,
|
|
.bInterval = 0x0A}));
|
|
config0.add_node(UsbDescriptorNode(USB_DESCRIPTOR_ENDPOINT,
|
|
UsbDeviceEndpoint {
|
|
.bEndpointAddress = 0x04,
|
|
.bmAttributes = 0x03,
|
|
.wMaxPacketSize = 0x0040,
|
|
.bInterval = 0x0A}));
|
|
|
|
add_string("THQ Inc");
|
|
add_string("THQ uDraw Game Tablet for PS3");
|
|
}
|
|
|
|
usb_device_gametablet::~usb_device_gametablet()
|
|
{
|
|
}
|
|
|
|
void usb_device_gametablet::control_transfer(u8 bmRequestType, u8 bRequest, u16 wValue, u16 wIndex, u16 wLength, u32 buf_size, u8* buf, UsbTransfer* transfer)
|
|
{
|
|
transfer->fake = true;
|
|
transfer->expected_count = buf_size;
|
|
transfer->expected_result = HC_CC_NOERR;
|
|
transfer->expected_time = get_timestamp() + 100;
|
|
|
|
// Control transfers are nearly instant
|
|
switch (bmRequestType)
|
|
{
|
|
case 0U /*silences warning*/ | LIBUSB_ENDPOINT_OUT | LIBUSB_REQUEST_TYPE_CLASS | LIBUSB_RECIPIENT_INTERFACE: // 0x21
|
|
switch (bRequest)
|
|
{
|
|
case 0x09: // SET_REPORT
|
|
ensure(buf_size > 2);
|
|
gametablet_log.trace("Leds: %s/%s/%s/%s",
|
|
buf[2] & 1 ? "ON" : "OFF",
|
|
buf[2] & 2 ? "ON" : "OFF",
|
|
buf[2] & 4 ? "ON" : "OFF",
|
|
buf[2] & 8 ? "ON" : "OFF");
|
|
break;
|
|
default:
|
|
gametablet_log.error("Unhandled Request: 0x%02X/0x%02X", bmRequestType, bRequest);
|
|
break;
|
|
}
|
|
break;
|
|
default:
|
|
usb_device_emulated::control_transfer(bmRequestType, bRequest, wValue, wIndex, wLength, buf_size, buf, transfer);
|
|
break;
|
|
}
|
|
}
|
|
|
|
extern bool is_input_allowed();
|
|
|
|
void usb_device_gametablet::interrupt_transfer(u32 buf_size, u8* buf, u32 /*endpoint*/, UsbTransfer* transfer)
|
|
{
|
|
ensure(buf_size > 0x1a);
|
|
|
|
transfer->fake = true;
|
|
transfer->expected_count = 27;
|
|
transfer->expected_result = HC_CC_NOERR;
|
|
// Interrupt transfers are slow (6ms, TODO accurate measurement)
|
|
transfer->expected_time = get_timestamp() + 6000;
|
|
|
|
std::memset(buf, 0, buf_size);
|
|
|
|
buf[0x02] = 0x0f; // dpad
|
|
|
|
buf[0x03] = 0x80;
|
|
buf[0x04] = 0x80;
|
|
buf[0x05] = 0x80;
|
|
buf[0x06] = 0x80;
|
|
|
|
buf[0x0d] = 0x72; // pressure
|
|
buf[0x0f] = 0x0f; // pos X
|
|
buf[0x10] = 0x0f; // pos Y
|
|
buf[0x11] = 0xff;
|
|
buf[0x12] = 0xff;
|
|
|
|
buf[0x13] = 0x01; // accel X
|
|
buf[0x14] = 0x02;
|
|
buf[0x15] = 0x00; // accel Y
|
|
buf[0x16] = 0x02;
|
|
buf[0x17] = 0xea; // accel Z
|
|
buf[0x18] = 0x01;
|
|
|
|
buf[0x1a] = 0x02;
|
|
|
|
if (!is_input_allowed())
|
|
{
|
|
return;
|
|
}
|
|
|
|
if (g_cfg.io.mouse != mouse_handler::basic)
|
|
{
|
|
gametablet_log.warning("GameTablet requires mouse_handler configured to basic");
|
|
return;
|
|
}
|
|
|
|
bool up = false, right = false, down = false, left = false;
|
|
|
|
{
|
|
std::lock_guard lock(pad::g_pad_mutex);
|
|
const auto gamepad_handler = pad::get_current_handler();
|
|
const auto& pads = gamepad_handler->GetPads();
|
|
|
|
const int pad_index = 1; // Player2
|
|
const auto& pad = ::at32(pads, pad_index);
|
|
if (pad->m_port_status & CELL_PAD_STATUS_CONNECTED)
|
|
{
|
|
for (Button& button : pad->m_buttons)
|
|
{
|
|
if (!button.m_pressed)
|
|
{
|
|
continue;
|
|
}
|
|
|
|
if (button.m_offset == CELL_PAD_BTN_OFFSET_DIGITAL1)
|
|
{
|
|
switch (button.m_outKeyCode)
|
|
{
|
|
case CELL_PAD_CTRL_SELECT:
|
|
buf[1] |= (1 << 0);
|
|
break;
|
|
case CELL_PAD_CTRL_START:
|
|
buf[1] |= (1 << 1);
|
|
break;
|
|
case CELL_PAD_CTRL_UP:
|
|
up = true;
|
|
break;
|
|
case CELL_PAD_CTRL_RIGHT:
|
|
right = true;
|
|
break;
|
|
case CELL_PAD_CTRL_DOWN:
|
|
down = true;
|
|
break;
|
|
case CELL_PAD_CTRL_LEFT:
|
|
left = true;
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
else if (button.m_offset == CELL_PAD_BTN_OFFSET_DIGITAL2)
|
|
{
|
|
switch (button.m_outKeyCode)
|
|
{
|
|
case CELL_PAD_CTRL_SQUARE:
|
|
buf[0] |= (1 << 0);
|
|
break;
|
|
case CELL_PAD_CTRL_CROSS:
|
|
buf[0] |= (1 << 1);
|
|
break;
|
|
case CELL_PAD_CTRL_CIRCLE:
|
|
buf[0] |= (1 << 2);
|
|
break;
|
|
case CELL_PAD_CTRL_TRIANGLE:
|
|
buf[0] |= (1 << 3);
|
|
break;
|
|
case CELL_PAD_CTRL_PS:
|
|
buf[1] |= (1 << 4);
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
if (!up && !right && !down && !left)
|
|
buf[0x02] = 0x0f;
|
|
else if (up && !left && !right)
|
|
buf[0x02] = 0x00;
|
|
else if (up && right)
|
|
buf[0x02] = 0x01;
|
|
else if (right && !up && !down)
|
|
buf[0x02] = 0x02;
|
|
else if (down && right)
|
|
buf[0x02] = 0x03;
|
|
else if (down && !left && !right)
|
|
buf[0x02] = 0x04;
|
|
else if (down && left)
|
|
buf[0x02] = 0x05;
|
|
else if (left && !up && !down)
|
|
buf[0x02] = 0x06;
|
|
else if (up && left)
|
|
buf[0x02] = 0x07;
|
|
|
|
auto& mouse_handler = g_fxo->get<MouseHandlerBase>();
|
|
std::lock_guard mouse_lock(mouse_handler.mutex);
|
|
|
|
mouse_handler.Init(1);
|
|
|
|
const uint8_t mouse_index = 0;
|
|
if (mouse_index >= mouse_handler.GetMice().size())
|
|
{
|
|
return;
|
|
}
|
|
|
|
const Mouse& mouse_data = ::at32(mouse_handler.GetMice(), mouse_index);
|
|
if (mouse_data.x_max <= 0 || mouse_data.y_max <= 0)
|
|
{
|
|
return;
|
|
}
|
|
|
|
static uint8_t noise_x = 0; // Toggle the LSB to simulate a noisy signal, Instant Artist dislikes a pen held perfectly still
|
|
static uint8_t noise_y = 0;
|
|
const int tablet_max_x = 1920;
|
|
const int tablet_max_y = 1080;
|
|
|
|
const long tablet_x_pos = (mouse_data.x_pos * tablet_max_x / mouse_data.x_max) ^ noise_x;
|
|
const long tablet_y_pos = (mouse_data.y_pos * tablet_max_y / mouse_data.y_max) ^ noise_y;
|
|
noise_x = !noise_x;
|
|
noise_y = !noise_y;
|
|
|
|
buf[0x0b] = 0x40; // pen
|
|
buf[0x0d] = mouse_data.buttons & CELL_MOUSE_BUTTON_1 ? 0xbb : 0x72; // pressure
|
|
buf[0x0f] = tablet_x_pos / 0x100;
|
|
buf[0x10] = tablet_y_pos / 0x100;
|
|
buf[0x11] = tablet_x_pos % 0x100;
|
|
buf[0x12] = tablet_y_pos % 0x100;
|
|
}
|