Long-shot: Support Impulse Triggers / Adaptive Triggers

[Monkatraz]

I know that this is a bit out of scope, but if it was supported it would basically make gameinput2xinput have feature-parity with the native implementation for many games.

I found an interesting project (x1nput) that converts xinput rumble into trigger impulses. For gameinput2xinput, this is interesting because we already have the calls from gameinput - we just need to send the effects to the controller. I would try this myself but I'm not really sure how to best test and develop this, lol. I've touched a lot of languages but I've never done anything with cpp, I'm not even sure how to really build the dll lmao

I'm guessing the biggest complications is getting an HID handle on any compatible controllers in a way that doesn't break on Linux or Windows. I'm not sure if Proton/Wine "hides" the controller device from you when xinput is being used, or if it's just adding a virtual controller that can be listened to.

I'd love to try this myself if you had any pointers on where I should start - I think using the x1nput library as reference would help me a lot.

EDIT: I guess the Big Brain™ version of this is for compatible controllers passing through all vibration effects from the game but keeping the rest as xinput.

[Monkatraz]

Actually, like was suggested, you can use windows.gaming.input on Proton it seems, seems to me that the vibration API there is supported. It's apparently hooked into when Steam Input is enabled, so this should Just Work™, maybe? I'm not sure what happens when you use a Dualshock though, but if the Dualshock Steam Input driver does handle this somewhat it would enable at least some nice vibration effects.

[Monkatraz]

I also found that there is this API in Steam Input you can use for the Dualsense: https://partner.steamgames.com/doc/api/isteaminput#SetDualSenseTriggerEffect

And this one for impulse triggers: https://partner.steamgames.com/doc/api/isteaminput#TriggerVibration

[Monkatraz]

Okay I decided to git gud and try it myself, and It Works (TM). I was able to figure out how to build on Linux (wine version of msvc) and I was able to link against the steam_api64.dll, with the valid assumption that the game was already linking against it. I then added:

• explicitly added support for left trigger and right trigger rumble in the device specs
• called SteamInput()->Init() in GameInputCreate
• replaced the rumble via xinput with rumble via steam input
• profit??

The rumble code looks like:

auto handle = SteamInput()->GetControllerForGamepadIndex(_deviceState->xinputSlot);

UINT16 low = params != nullptr ? static_cast<UINT16>(params->lowFrequency * 65536.0f) : 0ui16;
UINT16 high = params != nullptr ? static_cast<UINT16>(params->highFrequency * 65536.0f) : 0ui16;
UINT16 left = params != nullptr ? static_cast<UINT16>(params->leftTrigger * 65536.0f) : 0ui16;
UINT16 right = params != nullptr ? static_cast<UINT16>(params->rightTrigger * 65536.0f): 0ui16;
SteamInput()->TriggerVibrationExtended(handle, low, high, left, right);

LOG(AixLog::Severity::info)
    << "steam input: set rumble on input,"
    << " low " << low
    << " high " << high
    << " left " << left
    << " right " << right
    << std::endl;

with successful logs like:

2024-12-03 21-49-39.117 [Info] (SetRumbleState) steam input: set rumble on input, low 0 high 9810 left 0 right 9810
2024-12-03 21-49-39.141 [Info] (SetRumbleState) steam input: set rumble on input, low 0 high 15015 left 0 right 15015
2024-12-03 21-49-39.165 [Info] (SetRumbleState) steam input: set rumble on input, low 0 high 20145 left 0 right 20145
2024-12-03 21-49-39.187 [Info] (SetRumbleState) steam input: set rumble on input, low 0 high 24920 left 0 right 24920
2024-12-03 21-49-39.209 [Info] (SetRumbleState) steam input: set rumble on input, low 0 high 29843 left 0 right 29843

on my Dualsense, it feels like it's only firing the high-frequency motor when firing (and not the triggers) and I don't have a Series controller to test with - my next experiment will be trying to get adaptive triggers to work in some way. Steam Input might be firing the adaptive trigger just at a low level or something. low frequency and high frequency rumble definitely work though!

[andrew-ld]

hello, i'm open to accept that different api's are used if they improve the user experience without breaking compatibility, the best thing would be to try to use steaminput but if it fails it will fallback to the current implementation (example: it's not a game started from steam).

I would appreciate if you also could make a pr to compile with wine (I guess winegcc?)

I currently boot a VM with Windows every time, I haven't had enough time to be able to get it compiled from Linux

[Monkatraz]

To compile, I've used this script: https://github.com/mstorsjo/msvc-wine and then in the project directory doing cl steam_api64.lib dllmain.cpp /LD /Fo:gameinput. To get IDE support, I used the clangd LSP and used that script's instructions to get $INCLUDE and $LIB variables that I then shoved in a .clangd. I can make a PR for it, maybe? I went down a rabbit hole using mingw and just could not get it to work, but the moment I tried a wine'd msvc it worked

I've experimented with Dualsense trigger support and since I don't have a Xbox Series controller I'm not sure what to tune for - the Dualsense's triggers are more about response then they are about "rumble". Here is what I have so far:

auto xinputSlot = _deviceState->xinputSlot;

if (xinputSlot != -1)
{
    InputHandle_t handle = SteamInput()->GetControllerForGamepadIndex(_deviceState->xinputSlot);

    UINT16 low = params != nullptr ? static_cast<UINT16>(params->lowFrequency * 65536.0f) : 0ui16;
    UINT16 high = params != nullptr ? static_cast<UINT16>(params->highFrequency * 65536.0f) : 0ui16;
    UINT16 left = params != nullptr ? static_cast<UINT16>(params->leftTrigger * 65536.0f) : 0ui16;
    UINT16 right = params != nullptr ? static_cast<UINT16>(params->rightTrigger * 65536.0f): 0ui16;

    ScePadTriggerEffectParam param;
    memset(&param, 0, sizeof(param));
    param.triggerMask = SCE_PAD_TRIGGER_EFFECT_TRIGGER_MASK_L2 | SCE_PAD_TRIGGER_EFFECT_TRIGGER_MASK_R2;

    if (params != nullptr) {
      // prioritize lower frequencies, high frequencies just make a lot of noise but otherwise
      // feel fairly imperceptible
      float frequency = ((0.325f
        + (sqrtf(params->lowFrequency) * 0.25f))
        - (params->highFrequency * params->highFrequency * 0.125f)) * 255.0f;

      for (int i = 0; i < 2; i++) {
        int side = i == 0 ? SCE_PAD_TRIGGER_EFFECT_PARAM_INDEX_FOR_L2 : SCE_PAD_TRIGGER_EFFECT_PARAM_INDEX_FOR_R2;
        float trigger = i == 0 ? params->leftTrigger : params->rightTrigger;

        // too low of an amplitude is just not very noticeable, so we'll bias towards a
        // stronger low value response
        float amplitude = sqrt(trigger) * 8.0f;

        if (trigger > 0.0f) {
          param.command[side].mode = SCE_PAD_TRIGGER_EFFECT_MODE_MULTIPLE_POSITION_VIBRATION;
          param.command[side].commandData.multiplePositionVibrationParam.frequency = static_cast<UINT8>(frequency);

          // skipping the first position feels a little better, you "run into" the first vibration point
          for (int j = 1; j < SCE_PAD_TRIGGER_EFFECT_CONTROL_POINT_NUM; j++) {
            param.command[side].commandData.multiplePositionVibrationParam.amplitude[j] = static_cast<UINT8>(amplitude);
          }
        } else {
          param.command[side].mode = SCE_PAD_TRIGGER_EFFECT_MODE_OFF;
        }
      }
    } else {
      param.command[SCE_PAD_TRIGGER_EFFECT_PARAM_INDEX_FOR_L2].mode = SCE_PAD_TRIGGER_EFFECT_MODE_OFF;
      param.command[SCE_PAD_TRIGGER_EFFECT_PARAM_INDEX_FOR_R2].mode = SCE_PAD_TRIGGER_EFFECT_MODE_OFF;
    }

    // order matters, we need the dualsense effect to take priority
    SteamInput()->TriggerVibrationExtended(handle, low, high, left, right);
    SteamInput()->SetDualSenseTriggerEffect(handle, &param);
  }
}

It's not perfect though, it has a particular issue with when you bring the trigger all the way down it just kind of makes noise and struggles to vibrate, because the motors aren't really meant for this. I also don't think your meant to use the API this way - you're supposed to set the feedback effect up ahead of time and let the controller handle it, but here we're just bombarding the controller with new effect parameters.

I can try to make a PR but this is literally the first time I've touched C++ lmao, I'm not sure how to handle dynamically linking to steam_api64.dll if it's available. FYI, I got the headers and the steam_api64.lib from here https://github.com/rlabrecque/SteamworksSDK

[andrew-ld]

I don't think we can load steam_api64.dll from the dll, we have to expect the game to load its copy into memory and we start using it only if the SteamInput symbol is present in memory.

[Monkatraz]

Yeah I'm not the expert here on that. I played around with it more and it definitely is a feasible strategy. I wonder if it's better to just make a separate version of the dll meant for steam input rather than doing this dynamically. Like I'm not sure how this works but like what if the gameinput.dll was loaded before steam_api64.dll and we fallback to xinput when we don't need to?

[andrew-ld]

checking if a symbol is present is practically without overhead, you can make it that it is checked every X attempts (until it is found) to rumble and switch from xinput to steaminput automatically

[Monkatraz]

Okay, I've done two things:

1. I've successfully figured out how to get the existing steam_api64.dll module at runtime rather than enforcing a link to it. It turns out that this is pretty tricky because the SteamInput() accessor is actually an inlined function so I had to "recreate" the macro and fetch private internal functions from the module. It should be fine since it's replicating exactly what is shown in the headers so as long as we always keep the accessor impl up to date with whatever headers are used it should work.
2. I got an Xbox Series controller so I can test functionality. I've confirmed that the impulse triggers work correctly using Steam Input! It also revealed to me exactly how I could try to tune the Dualsense adaptive triggers to feel similar.

Although, it turns out in regards to the Dualsense that, at least with SteamInput, putting the adaptive triggers into any state other than "OFF" disables rumble emulation. So if the trigger is vibrating, the controller body won't. There is technically a fix for this - you have to send the rumble to the actual Dualsense haptics, which is the 3rd and 4th channels on the Dualsense's audio device. The problem is that the way the Dualsense canonically emulates rumble isn't like, public or anything, so we'd have to send our own waveforms and that sounds like a mess. I think for right now what we can get merged is something that lets impulse triggers work on controllers that support them - we can check for the Xbox One handle type in SteamInput and I've already confirmed that this works.

I can probably work on a PR this weekend. I'm curious if rather than just handling rumble via SteamInput if we should try to do everything through SteamInput - I'm not sure if there are any advantages to doing so, but it would at least feel more consistent. I think the main advantage would be getting controllers that have grip buttons to work?

Also, if you know of any other games that use GameInput that we can test with I'd like to know. It turns out Stalker 2 has some pretty basic rumble - it 99% of the time uses the high frequency motor and the right trigger motor, usually at the same strength. Not very dynamic lol

EDIT: Oh, and I suppose if any game used the controller's gyro we could probably pipe that through too, but I suspect that since Xbox controllers don't have gyros there isn't much of a point and I doubt any game uses them.

[Monkatraz]

Here ya go #6

[Howarddj]

@Monkatraz there has been an update in the source code to get the dll working again with Latest stalker 2 patch. if you get time could you update and rebuild your fork so i can try out the impulse triggers in game?

[andrew-ld]

now i send a build with latest patches, so i could have some feedback regarding this patch

[andrew-ld]

gameinput2xinput.zip

[Howarddj]

what feedback do you need for this? ive been using it for a few hours. everything works, rumble works. let me know what feedback you need and ill provide if i can