☰

O que a "Calibração de dispositivos de jogo" do Windows realmente faz?

tag-icon • tag-icon windows game-controller calibration
O que a "Calibração de dispositivos de jogo" do Windows realmente faz?

O que esse assistente realmente faz? Cria zonas mortas e as armazena no registro? Ele mapeia dados brutos para limites superiores e inferiores em algum lugar?

Esta é exclusivamente uma calibração de software ou envia dados de volta para o dispositivo?

Gostaria de saber se a saída deste assistente pode ser identificada para que a calibração possa ser disponibilizada em meu aplicativo.

Responder1

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

  • Após passar pelo assistente de calibração, são gravados os seguintes registros 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, são criados seis valores de chave de registro. 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 Eixo 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 médio 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ínimo, médio e máximo acima). Por exemplo, suponha que meu analógico esquerdo com defeito leia de 10 a 100 para movimento horizontal (eixo x), quando deveria estar na faixa de 0 a 255. Então 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 este 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 específico, você pode considerar o uso de alguma API do Windows para ler os valores (por exemplo, XInput, API UWP). 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));
    }
}

Responder2

Acredito que as informações de calibração estão 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.

informação relacionada