Qual è il modo più veloce per determinare la pressione di un tasto e il mantenimento della chiave in Win32?

Question

Qual è il modo più veloce per determinare la pressione di un tasto e anche come determinare se un tasto è in attesa? Sembra che la messaggistica delle finestre sia lenta. Fornisci un esempio di come farlo e perché è più veloce di un'alternativa.

Per essere chiari, questo per un loop di tempo reale (una simulazione), quindi sto cercando il modo più veloce per determinare se un tasto è stato premuto e anche per verificare se è tenuto.

Answer 1

GetAsyncKeyState() è quello che stai cercando. Legge lo stato fisico della tastiera, indipendentemente dallo stato della coda di input. Se è impostato il bit più alto, il tasto è stato disattivato al momento della chiamata.

// Fetch tab key state. 
SHORT tabKeyState = GetAsyncKeyState(VK_TAB); 

// Test high bit - if set, key was down when GetAsyncKeyState was called. 
if((1 << 15) & tabKeyState) 
{ 
    // TAB key down... 
} 

Inoltre, per la cronologia, Windows non è un sistema operativo in tempo reale. Se la tua applicazione richiede precisione in tempo reale, potresti voler selezionare un'altra piattaforma.

Answer 2

Considerando che tutte le comunicazioni inter-windows sono tramite Windows Messaging (eventi di tastiera, eventi del mouse, praticamente tutti gli eventi che si possono immaginare), non esiste un modo inferiore per accedere agli eventi della tastiera (a meno che non si scriva il proprio driver della tastiera) che conosco.

DirectX utilizza ancora la messaggistica da tastiera di Windows per fornire ai programmatori DirectX un accesso più semplice agli eventi della tastiera.

Aggiornato

mia nota su DirectX non era quello di usarlo, ma che quando Microsoft ha voluto fare un'interfaccia per i programmatori di utilizzare per i giochi in tempo reale, che ancora scritto DirectX in cima al di Windows Message Queue .

Suggerirei di dare un'occhiata a come scrivere un programma che può leggere direttamente dalla coda dei messaggi. Credo che ci sia un buon esempio Code Project Windows Message Handling - Part 1.

Le tue due opzioni sono leggere dalla coda messaggi (memorizzate nel buffer) o leggere direttamente dallo stato della tastiera (come afferma Bukes), il che significa che il tuo loop potrebbe tecnicamente perdere un evento della tastiera per un numero qualsiasi di motivi.

Answer 3

Se si desidera solo per interrogare lo stato della tastiera in modo da scoprire quali tasti sono su/giù così come il spostamento/alt/ctrl stato, basta chiamare GetKeyboardState (MSDN reference).

Quando ho lavorato in uno studio di gioco, questo è esattamente il modo in cui abbiamo ottenuto lo stato della tastiera per ciascun fotogramma. Dovrebbe essere applicabile al tuo codice di simulazione.

Answer 4

TL; DR: è possibile utilizzare GetAsyncKeyState per verificare se una chiave è attualmente verso il basso, ma per la migliore risposta delle applicazioni alla pressione dei tasti e rilascia, si desidera utilizzare il codice di condotta Win32 vicino al fondo del mio post.

GetAsyncKeyState opere perfettamente bene per determinare se una chiave è attualmente verso il basso, ma in termini di determinare se un tasto è stato premuto o rilasciato e quante volte questo è stato fatto, GetAsyncKeyState perde delle battute in una CPU- applicazione intensiva, anche dopo aver memorizzato lo stato della chiave precedente.

questo era quello che ho provato:

static const unsigned int NumberOfKeys = 256U; 

bool previousKeyboardState[NumberOfKeys]; 

//Get the current state of each key as the application starts to ensure that keys held down beforehand are not processed as pressed keys. 
for (unsigned int keyNum = 0U; keyNum < NumberOfKeys; ++keyNum) 
{ 
    previousKeyboardState[keyNum] = isKeyDown(keyNum); 
} 

//Works fine. 
bool isKeyDown(int key) 
{ 
    return (GetAsyncKeyState(key) & (1 << 16)); 
} 

//Misses key presses when application is bogged down. 
bool isKeyFirstPressed(int key) 
{ 
    bool previousState = previousKeyboardState[key]; 

    previousKeyboardState[key] = isKeyDown(key); 

    return (previousKeyboardState[key] && !previousState); 
} 

//Misses key releases when application is bogged down. 
bool isKeyFirstReleased(int key) 
{ 
    bool previousState = previousKeyboardState[key]; 

    previousKeyboardState[key] = isKeyDown(key); 

    return (!previousKeyboardState[key] && previousState); 
} 


//Example usage: 

if (isKeyDown(VK_W)) 
{ 
    //W key. 
} 

if (isKeyFirstReleased(VK_SNAPSHOT)) 
{ 
    //Print screen. 
} 

GetKeyboardState è non va bene neanche, in quanto non tiene traccia del numero di tasti da premere o rilasci. Come ha detto Erik Philips nella sua risposta, queste sono soluzioni senza buffer, che non vanno bene se si è, ad es. scrivere un gioco. Dovresti elaborare tutte le sequenze di tasti più velocemente di quanto non siano state ricevute.

Ora, il mio codice sopra funziona in modo decente e può essere adatto a molte persone, ma preferisco di gran lunga non perdere un singolo tasto. I odio utilizzando applicazioni che non rispondono. Penso che la soluzione migliore per le applicazioni Win32 sia quella di catturare i messaggi WM_KEYDOWN e WM_KEYUP nella pipeline ed elaborarli. La cosa bella è che WM_KEYDOWN fornisce anche un conteggio a ripetizione automatica, che potrebbe essere utile per le applicazioni che supportano l'immissione di testo (ad es. Chat, IDE, ecc.). Questo aggiunge anche una piccola complicazione, che è menzionato nella documentazione WM_KEYDOWN:

A causa della caratteristica Autorepeat, più di un messaggio WM_KEYDOWN può essere pubblicato prima che un messaggio WM_KEYUP è distaccato. Lo stato del tasto precedente (bit 30) può essere utilizzato per determinare se il messaggio WM_KEYDOWN indica la prima transizione verso il basso o una transizione verso il basso ripetuta.

Ci sono anche ganci per tastiera di Windows che è possibile esaminare, ma sono più difficili da usare. Sono bravi a ricevere key press globali.