O que a "calibração de dispositivo de jogo" do Windows realmente faz?

Da minha exploração recente da ferramenta de calibração do controlador de joystick integrado do Windows, posso confirmar o seguinte comportamento em um joystick PS4 (os resultados devem ser semelhantes para outros controladores):

• Depois de passar pelo assistente de calibração, os seguintes registros são escritos com os dados calibrados HKEY_CURRENT_USER\System\CurrentControlSet\Control\MediaProperties\PrivateProperties\DirectInput\<DEVICE_ID>\Calibration\0\Type\Axes\<NUM>, onde <NUM>é o número do eixo.

• Para um joystick PS4, o Windows lê seis eixos e, portanto, seis valores de chave de registro são criados. A numeração dos eixos é a seguinte:

  • 0 (x) --> Movimento horizontal do stick analógico esquerdo.
  • 1 (y) --> Movimento vertical do stick analógico esquerdo.
  • 2 (z) --> Movimento horizontal analógico direito.
  • 3 (Rx) --> gatilho L2.
  • 4 (Ry) --> Gatilho R2.
  • 5 (Rz) --> Movimento vertical analógico direito.

• O formato das chaves de registro é Calibrationmapeado para um valor binário de 12 bytes (codificado como <MIN> <MID> <MAX>). Por exemplo, meu Axis 0 (x) tem valor: <00 00 00 00> <80 00 00 00> <ff 00 00 00> que se traduz em

  • Valor mínimo do eixo 0 = <00 00 00 00> = 0 (decimal)
  • Valor do eixo central 0 = <80 00 00 00> = 128 (decimal)
  • Valor máximo do eixo 0 <ff 00 00 00> = 255 (decimal)

• A calibração que o Windows faz é converter os valores físicos em um intervalo calibrado (valores mínimos, médios e máximos acima). Por exemplo, suponha que meu stick analógico esquerdo com defeito lê de 10 a 100 para movimento horizontal (eixo x) quando deveria estar na faixa de 0 a 255. Em seguida, posso definir os valores mínimo/máximo para 10 e 100, respectivamente, para calibrar o stick analógico com defeito.

• Não parece haver uma configuração específica para zonas mortas, então presumo que seja um detalhe de implementação deixado para o aplicativo acima (por exemplo, para um jogo, definido como parte do código lógico do jogo).

• Como as configurações de calibração são armazenadas no registro, a calibração não é persistente em máquinas diferentes.

Quanto ao seu caso particular, você pode querer considerar o uso de alguma API do Windows para ler os valores (por exemplo, XInput, UWP API). Como bônus, aqui estão alguns dos meus bugs que lêem a entrada do controlador usando a API do Windows XInput.

#pragma comment(lib,"XInput.lib")
#pragma comment(lib,"Xinput9_1_0.lib")

#include <iostream>
#include <roapi.h>
#include <Xinput.h>


XINPUT_STATE fetchAConnectedJoystick() 
{
    DWORD dwResult;    
    XINPUT_STATE state;

    for (DWORD i=0; i < XUSER_MAX_COUNT; i++)
    {
        ZeroMemory(&state, sizeof(XINPUT_STATE));

        // Simply get the state of the controller from XInput.
        dwResult = XInputGetState(i, &state);

        // Controller is connected
        if(dwResult == ERROR_SUCCESS)
        {
            return state;
        }
    }

    std::exit;
}


void printLeftAnalogStickReadings(XINPUT_STATE state) 
{
    float LX = state.Gamepad.sThumbLX;
    float LY = state.Gamepad.sThumbLY;
    std::cout << "(X=" << LX << ", Y=" << LY << ")\n";
}


int computeAdjustedMagnitude(XINPUT_STATE state) 
{
    int INPUT_DEADZONE = 42;

    float LX = state.Gamepad.sThumbLX;
    float LY = state.Gamepad.sThumbLY;

    float magnitude = sqrt(LX*LX + LY*LY);              // Determine how far the controller is pushed

    // Determine the direction the controller is pushed
    float normalizedLX = LX / magnitude;
    float normalizedLY = LY / magnitude;

    if (magnitude > INPUT_DEADZONE)                     // Check if the controller is outside a circular dead zone
    {
        if (magnitude > 32767) magnitude = 32767;       // Clip the magnitude at its expected maximum value
        magnitude -= INPUT_DEADZONE;                    // Adjust magnitude relative to the end of the dead zone

    }
    else                                                // If the controller is in the deadzone zero out the magnitude
    {
        magnitude = 0.0;
    }
    return magnitude;
}


int main()
{
    XINPUT_STATE state;
    int sleepDuration = 100;                            // Milliseconds
    int adjustedMag = 0;

    while (true) {
        state = fetchAConnectedJoystick();
        printLeftAnalogStickReadings(state);
//      adjustedMag = computeAdjustedMagnitude(state);
//      std::this_thread::sleep_for(std::chrono::milliseconds(sleepDuration));
    }
}

Acredito que as informações de calibração estejam armazenadas no registro em:

HKEY_CURRENT_USER\System\CurrentControlSet\Control\MediaProperties\PrivateProperties\DirectInput\<DEVICE>\Calibration

Não sei qual é o formato das entradas, mas não é legível por humanos.