Quel est le moyen le plus rapide de déterminer une touche enfoncée et une clé dans Win32?

Quel est le moyen le plus rapide pour déterminer une pression sur une touche et aussi la façon de déterminer si une clé est-elle tenue? Il semble que la fenêtre de messagerie est lente. Veuillez fournir un exemple de la façon de le faire, et pourquoi il est plus rapide qu'une autre.

Pour être clair, ce pour un temps réel de la boucle (simulation) donc je suis à la recherche de la façon la plus rapide pour déterminer si une touche a été enfoncée et aussi pour vérifier si il est détenu.

source d'informationauteur judeclarke

  1. 21

    GetAsyncKeyState() est ce que vous cherchez. Il lit l'état physique du clavier, quelle que soit l'entrée de la file d'attente de l'état. Si la haute-bit est défini, puis sur la touche a été enfoncée au moment de l'appel.

    //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... 
}

    Également, pour mémoire, Windows n'est pas un système d'exploitation temps réel. Si votre application requiert en temps réel de précision, vous pouvez sélectionner une autre plate-forme.

  2. 6

    Si vous voulez juste pour interroger l'état du clavier afin de découvrir les touches up/down, ainsi que les maj/alt/ctrl état, il suffit d'appeler GetKeyboardState (Référence MSDN).

    Lorsque j'ai travaillé dans un studio de jeu, c'est exactement comment nous en sommes arrivés à l'état du clavier pour chaque image. Devraient être applicables à votre code de simulation.

  3. 2

    Considérant que toutes les fenêtres de communications à travers les fenêtres de messagerie (clavier événements, les événements de souris, à peu près tous les événements, vous pouvez l'imaginer), il n'y a pas une baisse du niveau moyen d'accéder aux événements de clavier (sauf si vous écrivez votre propre pilote de clavier), que je sache.

    DirectX utilise toujours le clavier windows messaging pour fournir DirectX programmeurs accès plus facile à des événements de clavier.

    Mis à jour

    Ma note sur DirectX a été de ne pas l'utiliser, mais que, lorsque Microsoft a voulu faire une interface pour les programmeurs à utiliser en temps réel à des jeux, ils écrivent encore DirectX sur le dessus de la Windows File d'attente de Messages.

    Je suggère de prendre un regard sur la façon d'écrire un programme qui permet de lire directement à partir de la file d'attente de messages. Je crois qu'il y en est un bon exemple Projet De Code De Windows Gestion Des Messages - Partie 1.

    Vos deux options sont à lire à partir de la file d'attente de messages (tampon) ou de lire directement à partir de l'état du clavier (comme Bukes unis), ce qui signifie que votre propre boucle peut techinically manquer un événement de clavier pour un certain nombre de raisons.

  4. 2

    TL;DR: vous pouvez utiliser GetAsyncKeyState pour vérifier si une clé est actuellement vers le bas, mais pour une meilleure réactivité de l'application de la clé de presses et communiqués, vous souhaitez utiliser Win32 pipeline code en bas de mon post.

    GetAsyncKeyState fonctionne parfaitement bien pour déterminer si une clé est actuellement vers le bas, mais en termes de déterminer si une touche a été premier enfoncé ou relâché et combien de fois cela a été fait, GetAsyncKeyState manque de frappes dans un PROCESSEUR d'application, même après le stockage de la clé précédente de l'état.

    C'est ce que j'ai essayé:

    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 n'est pas bon non plus, car il ne permet pas de garder une trace du nombre de touches ou de rejets. Comme Erik Philips a dit dans sa réponse, ce sont sans tampon solutions, qui ne sont pas bons si vous êtes par exemple l'écriture d'un jeu. Vous avez à traiter toutes les frappes de touches plus rapidement qu'ils sont reçus.

    Maintenant, mon code ci-dessus fonctionne décemment bien, et peut être adapté pour beaucoup de gens, mais je préfère ne pas manquer une seule frappe. Je haine à l'aide d'applications qui ne répondent pas. Je pense que la meilleure solution pour les applications Win32 est d'attraper WM_KEYDOWN et WM_KEYUP messages dans le pipeline et les processus. Ce qui est bien c'est que WM_KEYDOWN fournit également une auto-nombre de répétitions, ce qui pourrait être utile pour des applications qui prennent en charge la saisie de texte (par exemple, le chat, IDE, etc.). Cela ajoute aussi une légère complication, qui est mentionné dans la WM_KEYDOWN documentation:

    En raison de la autorepeat fonctionnalité, plus d'un message WM_KEYDOWN
    peut-être posté avant WM_KEYUP message est posté. La clé précédente
    l'état de bit (30) peut être utilisé pour déterminer si le message WM_KEYDOWN
    indique le premier bas de transition ou un répétée en bas de transition.

    Il y a aussi Windows crochets de clavier vous pouvez regarder, mais ceux-ci sont plus difficiles à utiliser. Ils sont bons pour la réception globale de touches.